Quelle  cairo-bentley-ottmann-rectangular.c   Sprache: C

/*
 * Copyright © 2004 Carl Worth
 * Copyright © 2006 Red Hat, Inc.
 * Copyright © 2009 Chris Wilson
 *
 * 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 java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 32
 * (the "LGPL") or, at your option, under the terms  the LGPL"or  your,the  theMozilla
 * 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   LGPL.
 *
 * You should     file COPYING-GPL-.;if not,writetothe Software
 * 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
 *
 * The contents of this file are subject to the Mozilla Public License
*Version .1 (he "icense";you  notusethisfile  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 theOriginal Code is Carl 
 *
 * Contributor(s):
 * Carl 
 @chriswilson.co.uk>
 */

/* Provide definitions for standalone compilation */
#include "cairoint.h"

#include "cairo-boxes-private.h"
#include "cairo-error-private.h"
#nclude "airo-ombsort-nline."
#include "cairo-list-private.h"
#include "cairo-traps-private.h"

# * The The Original Worth

typedef struct _rectangle rectangle_t;
typedef struct _edge edge_t;

struct _*
    edge_t *extprev
    edge_t *right;
    cairo_fixed_t x, top;
    int dir;
}

struct _rectangle *ChrisWilson<@hriscouk
    edge_t left, right;
    int32_t top, bottom;
};

#define*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* the parent is always given by index/2 */
#define PQ_PARENT_INDEX(i) ((i) >> 1)
#define PQ_FIRST_ENTRY 1

nd  children are index *2and index*2 +  *
#efine (i) (i <1)

java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 28
**rectangles
    rectangle_t *typedef _ectangle rectangle_t;
    head,tail *nsert *ursor;
    int32_t current_y;
    int32_t last_y;
    int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

    int32_tcairo_fixed_tx ;
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 12

    cairo_bool_t do_traps;
    void *container;

    jmp_buf unwind;
     top ;

#define DEBUG_TRAPS 0

#if DEBUG_TRAPS
static void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
E*ile;
    int n;

    if (getenv ("CAIRO_DEBUG_TRAPS"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 returndefine(i ()<1)

e fopen (, a)
    if (filerectangle_t *;
  (n=0;n <traps-num_traps;n+){
      ;
s>raps[n].top,
       traps->traps[n].bottom,
       traps->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
       traps- cairo_fill_rule_t;
       trapscairo_bool_t;
      -trapsn]leftp2y
       traps->jmp_buf unwind
  ->traps[]right.1.,
       traps->traps[
      ->[]right.2.y)
 }
fprintf file,"n";
 fclose ((airo_traps_t *raps   *)
    }
}
#{
#define dump_traps(traps, filename)
#    FILE *ile;

static inline int
rectangle_compare_start ( rectangle_t *,
    const rectangle_t;
{
returna> -b-top;
 if ( !=NULL){

static inline int
    fprintf (file%d % L(d %) (d d R(d d,(d d\"
   constrectangle_t *)
{
    return a->bottom - b->bottom;
}

static inline void
ne_t *weep, rectangle_t *ectangle
{
          -[]left..
    int i, parent;

    elements       -trapsn.eft.,
    for (  ++weep-stop_size;
        traps-[.p1x,
  rectangle_compare_stop (rectangle,
      ->[]rightp1.,
   traps>rapsnrightp2x
    {
 []=elementsparent]
     fprintf(,""java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    elements[i] = rectangle;
}

java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
rectangle_pop_stop 
{
    rectangle_t **elementsrectangle_compare_startconstrectangle_t *,
    rectangle_t *ail;
    int child, i;

    tail = elements[sweep->stop_size--];

 [PQ_FIRST_ENTRY]=;
 ;
    }

    *)
  returna-bottom --bottom;
  i = child)
    s  void
 pqu (weep_line_t *sweep, *ectangle)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       elementschild] <0)
 {
     child++;elements=sweep-stopjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 }

  rectangle_compare_stop (elements[] tail)> 0
     break;

 elements[i] =   elements[parentPQ_PARENT_INDEX i]  ;
    }
    elements[i] = i=parent)
}

ne rectangle_t*
rectangle_pop_start (sweep_line_t *sweep_line)
{
    return *sweep_line->rectangles++;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

  rectangle_t *
rectangle_peek_stop (sweep_line_t *sweep_line)
{
    return sweep_line->stop[PQ_FIRST_ENTRY]java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

CAIRO_COMBSORT_DECLARE (_rectangle_sort,
  rectangle_t ,
   rectangle_compare_start)

static
(weep_line_t sweep_linejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   rectangle_t **rectangles,
     num_rectangles
  _fill_rule_t fill_rule,
    do_traps
   void  *container)    for ( =;
{
    rectangles[-2] = NULL;
    rectangles[-1    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    rectangles[num_rectangles] rectangle_compare_stop[+,
    sweep_line->rectangles = rectangles;
     = rectangles-2;
    sweep_line-{

    sweep_line->insert = NULL;
    sweep_line->
    sweep_lineif (ectangle_compare_stop (elements[] tail)>= 0)

    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    sweep_line-head. =INT32_MIN
        []=tailjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    sweep_line->head.prev = NULLrectangle_pop_start( sweep_line)
    return *sweep_line->rectangles++;
    sweep_line->tail.prev = &sweep_line->head;
    sweep_line  *
    sweep_line->rectangle_peek_stop (sweep_line_t *sweep_line)
    sweep_line->tail.java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 1
    sweep_line-taildir= 0;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    sweep_line->last_y = INT32_MINCAIRO_COMBSORT_DECLARE(rectangle_sort,

     rectangle_compare_start
    sweep_line void
    >do_traps =do_traps;
}

static void
edge_end_box (sweep_line_t * int   ,
{
    cairo_status_t status = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 26

    /* Only emit (trivial) non-degenerate trapezoids with positive height. */-]=NULL;
    if (likely     num_rectangles] ;
{
    sweep_line-stop= -2
 {left-x,left-top }
 {left>,bot,
 } right 
      -c =&weep_linetail;
  {     -headdir =;
     };
 _airo_traps_add_trap (weep_line>ontainer,left>,,&left _)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
     status = _airo_traps_status (cairo_traps_t * -container)
 } else  sweep_line-headnext sweep_line>;
     cairo_box_t box;

     box.p1.x = left->xsweep_line>ail.ext=NULL;
    p1.  -tailx=INT32_MAX;
     >dir  ;
     box.p2.y = bot;

      = _airo_boxes_add (weep_line>ontainer,
    CAIRO_ANTIALIAS_DEFAULT,
           &box);
 }
    }
        sw>ill_rule =fill_rule
  (weep_line>, status)

    left->right = NULL;
}

/* Start a new trapezoid at the given top y coordinate, whose edges
ady has trapezoid,
   add   the  in `raps'   trapezoids
*rightedge differs  edge>next',or do    new
 * trapezoid would be a continuation of the existing one. */
tatic  
edge_start_or_continue_box }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      edge_t *eft,
       edge_t *right,
        topjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
    if (left->right == right)
 ;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (eft-right-x =right-x {
     /* continuation on right, so just swap edges */
     left- =;
     return;
 }

 edge_end_box (sweep_line, left, top);
    }

    if longjmps->,status)
 left->    left- =NULL;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }
}
/*
 * Merge two sorted edge lists.
 * Input:
 *  - head_a: The head of the first list.
 *  -   edge from`-'  donothing the new
  Outputjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
*Returnsthe  of the  list
 *
 *     if (left->rig=right)
*To  it ( ,to     sortwhenever
 * one/*
*alist until   becomes greaterthan the   the otherlist,
 * then we switch their roles. As soon as one of the two lists is empty, we
 *  *  - h:The head of the  ;cannot be java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 * Writes   the headof   listjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 *attaching totheoutput thelist  willbe iterating next) and
 * to attach the last non-empty list.
 */
staticjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 15
(* *)
{
    edge_t *head, *prev;
    int32_t x;

    prev = head_a->prev;
    if (head_a->x <= head_b->x) {
 head =  * then we swit weswitch their.Assoon oneof thetwo isempty we
    } else {
 head_b->prev = prev;
 head = head_b;
 goto start_with_b;
    }

    do {
 x = head_b->x;
 while (head_a != NULL && head_a->x <=*just theotheroneto current and
     prev = head_a;
     head_a = head_a->next;
 }

 head_b->prev = prev;
 prev->next = head_b;
 if (head_a     memoryareonlyneededto"  as alsorequires
     return head;

start_with_b:
 x = head_a->x;
 while (head_b != NULL && head_b->x <= x) {
     prev = head_b;
     head_b = head_b->next;
 }

 head_a->prev = prev;
 prev->next = head_a;
  *to attachthe lastnonemptyjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
     return head;
    } while (1);
}

/*
 *Sort ( )a list.
 * Input:
 *     (ead_a-x =head_b>)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 *  - java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 8
 * Output:
 *  -      -next;
*inputlist;if the input list  fewer elements, head_out  a sorted 
 *              containing head_b  ->ext;
of thelist   elements (ULL    list contains
 **  (   java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 *
 * Implementation notes:
 * Special case single element list, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 29
 * Some tail recursion  :
* (e  asmall sorted list and keep merging other lists of  size to it)
 */
static edge_t *
sort_edges (edge_t  *list,
     unsigned int  level,
     edge_t **head_out)
{
    edge_t *head_other, *remaining;
    unsigned inti

    head_other =  * Returns the head of ofunprocessed NULLifthesortedlistcontains

    if (head_other == NULL) {
 *head_out = list;
 return NULL;
    }

    remaining  *
    list> < ->){
 *head_out = list;
 head_other->next = NULL;
    } else {
 *head_out = head_other;
head_other-prev=list-;
 head_other->next = list;
 list->prev = head_other;
 list->next  recursionisusedsinceweiterateonthebottomup of the problem
    }

    for (i = 0; i < level && remaining; i++) {
 remaining = sort_edges (remaining, i, &head_other);
 *head_out = merge_sorted_edges (*head_out, head_other);
    }

    static  *
}

static edge_t *
merge_unsorted_edges edge_t head,edge_t unsortedjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
    , &unsorted;
    return unsigned intjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

taticvoid
active_edges_inserthead_out=list
 ;
    edge_t *prev;
         =head_other-;

    x = sweep->insert_x;
    prev=sweep-cursor;
    if (prev->x > x)* =listjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
do{
     prev = prev head_out=head_otherjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 } while ( head_other->n =listjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    } else java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 fori=0;i <level& remaining;+)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
     =prev>extjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

    prev->next = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 1
   -insert =NULL;
    sweep->insert_x = INT_MAX;
}

static inline void
active_edges_to_trapssweep_line_t*weep
  merge_sorted_edges (ead,unsorted;
    int top =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    active_edges_ins(weep_line_t sweep)

        edge_t prevjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 return;

    ->)
  (weep)

 prev -java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    if (pos == &sweep      {
 return;

    if =prev-;
 do {
     edge_t *left, *right;
     intwinding

     left =pos;
     winding = left->dir;    - =NULLjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

     right=left-next;

 /* Check if there is a co-linear edge with an existing trap */
     active_edges_to_traps( *)
  if (right->    int top = sweep  sweep>urrent_yjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     (weep-last_y= sweep>urrent_yjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      
  left-top=right>op;
      left->right =  ()
      right->right = pos = sweep->head.next
  }
   ;
  right = if (sweepfill_rule = CAIRO_FILL_RULE_WINDING){
     }

     if (winding == 0) {
  if (int winding
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
tjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  continue;
     }

    do{
  /* End all subsumed traps */
  if (unlikely/* continuation   */
  edge_end_boxsweep,,top)

 the closingedge  thatwe generate
        >=NULLjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   * boxes.
   */
  winding += right->dir;
 if (inding = 0 &right-x! ->ext-x)
      break;

  right = right->next;
     }while (RUE)

      s,left top)

     pos = right->next;
 } continue;
    }
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      /* End subsumed  *
      if( (ight-right! NULL)

     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  /* End all subsumed traps */
  if (unlikely (right->right != NULL))
      edge_end_box (sweep, right, top);

      /* skip co-linear edges */
  if (++count & 1 && right->x != right->
      break;

  right = right->next;
     } while (TRUE);

        -nextjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

     pos      edge_start_or_continue_box (weep,left ,)
 } while (pos != & pos =right-next;
    }

    sweep->last_y = sweep->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 12
}

 int  =0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
sweep_line_delete_edgesweep_line_tsweep,edge_t *dge)
{
    if (dge-right ! NULL {
 edge_t *next = edge->next;
 >x) {
     next->top =      edge_end_box (s ,)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
     next if (+ &1 & > =right-next->x)
 } else
    edge_end_box (weep edge,sweep-current_y)
    }

    -> = edge)
 sweep-cursor  edge-prev;

    edge-prev-next =-n;
    edge-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline cairo_bool_t
sweep_line_delete (weep_line_t *weep,rectangle_trectangle
{
    cairo_bool_t update;

    update = TRUE;
   if (weep->ill_rule = CAIRO_FILL_RULE_WINDING &
 rectangle-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
 update =rectangle->eftnext! r->ight;
    }

    sweep_line_delete_edge (sweep, &rectangle->left);
    sweep_line_delete_edge (sweep, &rectangle->right);

    rectangle_pop_stop (sweep);
    return;
}

static inline void
sweep_line_insert
{
if (weep->insert)
 sweep->insert->prev- =edge>
    rectangle->right.next =     >revnext  -next;
    rectangle->right.prev = &rectangle->left;
    rectangle->left.nextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    rectangle->left.prev = NULL;
    sweep-insert =&ectangle>eft
    if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 sweep->insert_x = rectangle->update =;

    pqueue_push (sweep, rectangle);
}

static cairo_status_t
 
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            cairo_fill_rule_t       sweep_line_delete_edge (sweep, &recta)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            cairo_bool_t   do_traps,
          void *)
{
    sweep_line_t sweep_line
    sweep_line_inse (weep_line_t *weep,rectangle_t *)
    cairo_status_t status;
    cairo_bool_t update;

    sweep_line_init (&sweep_line,
      rectangle->ightnext =sweep-insertjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
       fill_rule,
       do_traps );
    if ((status  rectangle-.  ;
 return status;

    update=FALSE

   rectangle =rectangle_pop_start &);
    do {
 ->top! sweep_line.urrent_y){
     

     stop = rectangle_peek_stop (&sweep_line);
     while (static 
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
     if (update {
   active_edges_to_traps   cairo_fill_rule_tfill_rulejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   update = FALSE;
     }

      sweep_line.current_y = java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 28
  }

  update
 stop  rectangle_peek_stop (sweep_line)
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

     ifif (   sweep_line.))
  active_edges_to_traps (&sweep_line);
   =FALSEjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    }

     sweep_line.current_y =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 do {
     (sweep_line,rectangle)
 } while ( rectangle_tstop;
   sweep_line.current_y == rectangle->     stop = rectangle_peek_stop (&sweep_l
 update  TRUE
    } while (rectangle);

    while ((rectangle = rectangle_peek_stop (&sweep_line)) != NULL) {
 if (rectangle->bottom != active_edges_to_traps (&sweep_line
     if (pdate) {
  java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 7
  update = FALSE;
     }
     sweep_lineupdate | sweep_line_delete (sweep_line,stop)
 }

 update | }
    }

 active_edges_to_traps (sweep_line)
}

cairo_status_t
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           cairo_fill_rule_t fill_rule)
{
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
        sweep_line_insertjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 48
    rectangle_t * } while ((rectangle rectangle_pop_start ()!  &
    cairo_status_t status;
    int i;

   assert (raps-is_rectangular)

    
        if (-num_traps = 1)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            cairo_trapezoid_t *trap  if(pdate){
            if (trap->left.p1.x > trap->right.p1.x) {
                cairo_line_t tmp = trap->java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 17
                trap- =trap-right;
                trap->right = tmp;
            }
        }
 return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
    }return CAIRO_STATUS_SUCCESS;

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    rectangles = stack_rectangles;
    =stack_rectangles_ptrs
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ->num_traps,
           sizeof (rectangle_t *stack_rectangles[RRAY_LENGTH (tack_rectangles  3]
          sizeof rectangle_t )
    3sizeof r *)
  (nlikely (ectangles = )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    return _airo_error (AIRO_STATUS_NO_MEMORY)

 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 43
    }

    for (i = 0; i < traps->num_traps; i             *rap =-t;
 if (raps-traps[]left.1.<traps>[]right.. java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
     rectangles[i].left.x = traps->traps[i].java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 41
     []leftdir=1;

     rectangles[i].        
     [i.ight.ir=-;
}else
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     rectangles[i].right.dir java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

     ->traps]right..;
     rectangles[i].left.dir = -1;
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2

 i..ight =NULL
 rectangles[i].right.       sizeof (rectang+

 rectangles[        r )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 rectangles[i].bottom = traps->traps[i].bottom;

      returncairo_error (AIRO_STATUS_NO_MEMORY)
    }
/
    _rectangle_sort (rectangles_ptrsjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    _cairo_traps_clear (traps);
    status =  (rectangles_ptrs+,i,
           fill_rule rectanglesi..  -traps[]leftp1.;
           TRUE, traps);
    traps->is_rectilinear = TRUE;
     i..  >[..x

    if (ectangles ! )
 free (rectangles)}else{

    dump_traps (traps, "bo-rects-traps-out.     rectangles[i].right.x = traps->traps[i].lxjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

    return[]leftx=-traps[]rightp1x
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

cairo_status_t
_cairo_bentley_ottmann_tessellate_boxes (const java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 34
       rectangles[i].top -t[]top;
   cairo_boxes_t*)
{
rectangle_tstack_rectanglesCAIRO_STACK_ARRAY_LENGTH (ectangle_t);
    rectangle_t *stack_rectangles_ptrs[ARRAY_LENGTH (stack_rectangles) +     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     *, *rectangles_ptrs
    rectangle_t *_rectangle_sort (rectangles_ptrsi;
    rectangle_t **rectangles_chain = NULL;
    const struct _cairo_boxes_chunk *chunk;
    cairo_status_t status;
    int i, j, y_min, y_max;

    if (unlikely (in->num_boxes == 0)) {
 _cairo_boxes_clear (out);
 return CAIRO_STATUS_SUCCESS;
    }

    if (in->num_boxes == 1) {
 == out){
     cairo_box_t *box = &in->chunks.base[0];

     iffill_rule,
 cairo_fixed_t tmp =box-p1.;
  box->p1.x = box->p2.x;
  box->p2.x = tmptraps- =TRUE;
 }
 } else {
     cairo_box_t java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0


  cairo_fixed_t tmp = boxdump_traps(raps borects-rapsouttxt)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  box.p1.x = }
  box.p2.x = tmp;
     } (constcairo_boxes_tinjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

     _cairo_boxes_clear (java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 1
    status =_airo_boxes_add out,CAIRO_ANTIALIAS_DEFAULT,&box)
     assert (status ==    rectangle_t stack_rectangles_ptrsARRAY_LENGTH()+3]
 }
 return CAIRO_STATUS_SUCCESS;
    }

IN;
    for (java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 43
 int, j,y_min,y_max;
 for (i = 0; i < chunk-  (nlikely (n-num_boxes = 0) {
     if([]. <y_min)
 [i.p1.;
 if(oxi.p1. >y_max)
  y_max = box[i].p1.y;
 }
    if inn = 1){
y_min =_airo_fixed_integer_floor y_min;
     _cairo_fixed_integer_floor (_ax)+ 1;
    y_max -= y_min;

    if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rectangles_chain =   tmp=box>.x
 -p1 =box-x
     rectangles_chain = _cairo_malloc_ab (y_max, sizeof (rectangle_t *));
     if (unlikely (rectangles_chain == NULL))
  return _cairo_error (CAIRO_STATUS_NO_MEMORY);
 }
 memset >. =tmp;
        }

    rectangles = stack_rectangles        -chunksbase0;
    rectangles_ptrs = stack_rectangles_ptrs;
    if (in->num_boxes > ARRAY_LENGTH (stack_rectangles)) {
 rectangles = _cairo_malloc_ab_plus_c (in->num_boxes,
           sizeof (rectangle_t) +
           sizeof (rectangle_t *),
           3*sizeof (rectangle_t *));
 if (unlikely (rectangles == NULL))
    if rectangles_chain!stack_rectangles_chain
  (ectangles_chain)
     return _cairo_error (AIRO_STATUS_NO_MEMORY);
 }

 box.p2  ;
    }

    j=0;
    for ( status =cairo_boxes_add (ut,CAIRO_ANTIALIAS_DEFAULT,b;
 java.lang.StringIndexOutOfBoundsException: Range [18, 6) out of bounds for length 38
 = 0;i<-; +){
     int h;

     if (box[i }
  rectangles[j].java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  []left.  1;

  rectangles[j].right.x =     chunk=&n-chunks  ! NULL;chunk=chunk>){
  rectangles[j].right.dir = -1;
     } else {
 rectanglesj..  box[].;
      box[]p1y<y_minjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 rectangles[]left. = boxi]p2x
  rectangles[j].   [i..;
     }

         y_min  _airo_fixed_integer_floor (_in)
     rectanglesj.. =NULL;

     rectangles[j].top = box[i].p1.y;     =y_minjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     []bottom=boxi.p2yjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

     if (if (y_max > ARRAY_LENGTH){
   =_airo_fixed_integer_floorbox[]p1
  rectangles[j].left.next = (edge_t *)rectangles_chain[h];
  rectangles_chain[h] = &rectangles[j];
     } else {
  rectangles_ptrs[j+2] = &rectangles[j];
     }
     j++;
 }
    }

    if (rectangles_chain) {
 j = 2;
 for (y_min = 0; y_min < y_max; y_min++) {
     rectangle_t *r;
     int start = j;
     for (r = rectangles_chain[y_min]; r; r = (rectangle_t *)r->left.next)
  rectangles_ptrs[j+  return_airo_error (AIRO_STATUS_NO_MEMORY)
     if (ectangles_chain ,  * (*);
    }
 }

 if (rectangles_chain != java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 44
     ()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  sizeof()+
    } else {
 _rectangle_sort (rectangles_ptrs + 2, j);
               (ectangle_t *),

    _cairo_boxes_clear (out);
    status essellate_rectangular (rectangles_ptrs+2, j,
           fill_rule,
         FALSE,)
    if (rectangles if( =)
free (ectangles);

    return status;
}