_cairo_array_init: 59| 43.7k|{ 60| 43.7k| array->size = 0; 61| 43.7k| array->num_elements = 0; 62| 43.7k| array->element_size = element_size; 63| | array->elements = NULL; 64| 43.7k|} _cairo_array_fini: 76| 43.7k|{ 77| 43.7k| free (array->elements); 78| 43.7k|} _cairo_array_grow_by: 90| 3|{ 91| 3| char *new_elements; 92| 3| unsigned int old_size = array->size; 93| 3| unsigned int required_size = array->num_elements + additional; 94| 3| unsigned int new_size; 95| | 96| | /* check for integer overflow */ 97| 3| if (required_size > INT_MAX || required_size < array->num_elements) ------------------ | Branch (97:9): [True: 0, False: 3] | Branch (97:36): [True: 0, False: 3] ------------------ 98| 0| return _cairo_error (CAIRO_STATUS_NO_MEMORY); 99| | 100| 3| if (CAIRO_INJECT_FAULT ()) ------------------ | | 47| 3|#define CAIRO_INJECT_FAULT() 0 | | ------------------ | | | Branch (47:30): [Folded, False: 3] | | ------------------ ------------------ 101| 0| return _cairo_error (CAIRO_STATUS_NO_MEMORY); 102| | 103| 3| if (required_size <= old_size) ------------------ | Branch (103:9): [True: 0, False: 3] ------------------ 104| 0| return CAIRO_STATUS_SUCCESS; 105| | 106| 3| if (old_size == 0) ------------------ | Branch (106:9): [True: 3, False: 0] ------------------ 107| 3| new_size = 1; 108| 0| else 109| 0| new_size = old_size * 2; 110| | 111| 3| while (new_size < required_size) ------------------ | Branch (111:12): [True: 0, False: 3] ------------------ 112| 0| new_size = new_size * 2; 113| | 114| 3| array->size = new_size; 115| 3| new_elements = _cairo_realloc_ab (array->elements, 116| 3| array->size, array->element_size); 117| | 118| 3| if (unlikely (new_elements == NULL)) { ------------------ | | 145| 3|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 3] | | ------------------ ------------------ 119| 0| array->size = old_size; 120| 0| return _cairo_error (CAIRO_STATUS_NO_MEMORY); 121| 0| } 122| | 123| 3| array->elements = new_elements; 124| | 125| 3| return CAIRO_STATUS_SUCCESS; 126| 3|} _cairo_array_index: 168| 1|{ 169| | /* We allow an index of 0 for the no-elements case. 170| | * This makes for cleaner calling code which will often look like: 171| | * 172| | * elements = _cairo_array_index (array, 0); 173| | * for (i=0; i < num_elements; i++) { 174| | * ... use elements[i] here ... 175| | * } 176| | * 177| | * which in the num_elements==0 case gets the NULL pointer here, 178| | * but never dereferences it. 179| | */ 180| 1| if (index == 0 && array->num_elements == 0) ------------------ | Branch (180:9): [True: 1, False: 0] | Branch (180:23): [True: 1, False: 0] ------------------ 181| 1| return NULL; 182| | 183| 1| assert (index < array->num_elements); ------------------ | Branch (183:5): [True: 0, False: 0] | Branch (183:5): [True: 0, False: 0] ------------------ 184| | 185| 0| return array->elements + (size_t)index * array->element_size; 186| 0|} _cairo_array_allocate: 316| 3|{ 317| 3| cairo_status_t status; 318| | 319| 3| status = _cairo_array_grow_by (array, num_elements); 320| 3| if (unlikely (status)) ------------------ | | 145| 3|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 3] | | ------------------ ------------------ 321| 0| return status; 322| | 323| 3| assert (array->num_elements + num_elements <= array->size); ------------------ | Branch (323:5): [True: 0, False: 3] | Branch (323:5): [True: 3, False: 0] ------------------ 324| | 325| 3| *elements = array->elements + (size_t)array->num_elements * array->element_size; 326| | 327| 3| array->num_elements += num_elements; 328| | 329| 3| return CAIRO_STATUS_SUCCESS; 330| 3|} _cairo_user_data_array_init: 372| 42.9k|{ 373| 42.9k| _cairo_array_init (array, sizeof (cairo_user_data_slot_t)); 374| 42.9k|} _cairo_user_data_array_fini: 385| 42.9k|{ 386| 42.9k| unsigned int num_slots; 387| | 388| 42.9k| num_slots = array->num_elements; 389| 42.9k| if (num_slots) { ------------------ | Branch (389:9): [True: 0, False: 42.9k] ------------------ 390| 0| cairo_user_data_slot_t *slots; 391| | 392| 0| slots = _cairo_array_index (array, 0); 393| 0| while (num_slots--) { ------------------ | Branch (393:9): [True: 0, False: 0] ------------------ 394| 0| cairo_user_data_slot_t *s = &slots[num_slots]; 395| 0| if (s->user_data != NULL && s->destroy != NULL) ------------------ | Branch (395:10): [True: 0, False: 0] | Branch (395:34): [True: 0, False: 0] ------------------ 396| 0| s->destroy (s->user_data); 397| 0| } 398| 0| } 399| | 400| 42.9k| _cairo_array_fini (array); 401| 42.9k|} cairo-pattern.c:_cairo_atomic_int_cmpxchg_impl: 92| 311|{ 93| 311| int expected = oldv; 94| | return atomic_compare_exchange_strong_explicit (x, &expected, newv, memory_order_seq_cst, memory_order_seq_cst); 95| 311|} cairo-pattern.c:_cairo_atomic_int_get_relaxed: 67| 85.9k|{ 68| | return atomic_load_explicit (x, memory_order_relaxed); 69| 85.9k|} cairo-pattern.c:_cairo_atomic_ptr_get: 79| 42.9k|{ 80| | return atomic_load_explicit (x, memory_order_seq_cst); 81| 42.9k|} cairo-pattern.c:_cairo_atomic_ptr_cmpxchg_impl: 115| 48.8k|{ 116| 48.8k| void *expected = oldv; 117| | return atomic_compare_exchange_strong_explicit (x, &expected, newv, memory_order_seq_cst, memory_order_seq_cst); 118| 48.8k|} cairo-pattern.c:_cairo_atomic_int_set_relaxed: 73| 11.7k|{ 74| | atomic_store_explicit (x, val, memory_order_relaxed); 75| 11.7k|} cairo-pattern.c:_cairo_atomic_int_get: 61| 86.0k|{ 62| | return atomic_load_explicit (x, memory_order_seq_cst); 63| 86.0k|} cairo-surface.c:_cairo_atomic_int_cmpxchg_impl: 92| 1|{ 93| 1| int expected = oldv; 94| | return atomic_compare_exchange_strong_explicit (x, &expected, newv, memory_order_seq_cst, memory_order_seq_cst); 95| 1|} cairo-surface.c:_cairo_atomic_int_get: 61| 5|{ 62| | return atomic_load_explicit (x, memory_order_seq_cst); 63| 5|} cairo-freed-pool.c:_cairo_atomic_ptr_get: 79| 594k|{ 80| | return atomic_load_explicit (x, memory_order_seq_cst); 81| 594k|} cairo-freed-pool.c:_cairo_atomic_ptr_cmpxchg_impl: 115| 1.18M|{ 116| 1.18M| void *expected = oldv; 117| | return atomic_compare_exchange_strong_explicit (x, &expected, newv, memory_order_seq_cst, memory_order_seq_cst); 118| 1.18M|} cairo-freed-pool.c:_cairo_atomic_int_set_relaxed: 73| 74.2k|{ 74| | atomic_store_explicit (x, val, memory_order_relaxed); 75| 74.2k|} _cairo_color_double_to_short: 86| 72.0k|{ 87| 72.0k| return d * 65535.0 + 0.5; 88| 72.0k|} _cairo_color_init_rgba: 103| 18.0k|{ 104| 18.0k| color->red = red; 105| 18.0k| color->green = green; 106| 18.0k| color->blue = blue; 107| 18.0k| color->alpha = alpha; 108| | 109| 18.0k| _cairo_color_compute_shorts (color); 110| 18.0k|} cairo-color.c:_cairo_color_compute_shorts: 92| 18.0k|{ 93| 18.0k| color->red_short = _cairo_color_double_to_short (color->red * color->alpha); 94| 18.0k| color->green_short = _cairo_color_double_to_short (color->green * color->alpha); 95| 18.0k| color->blue_short = _cairo_color_double_to_short (color->blue * color->alpha); 96| 18.0k| color->alpha_short = _cairo_color_double_to_short (color->alpha); 97| 18.0k|} cairo_device_reference: 208| 1|{ 209| 1| if (device == NULL || ------------------ | Branch (209:9): [True: 1, False: 0] ------------------ 210| 0| CAIRO_REFERENCE_COUNT_IS_INVALID (&device->ref_count)) ------------------ | | 58| 0|#define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 53| 0|#define CAIRO_REFERENCE_COUNT_GET_VALUE(RC) _cairo_atomic_int_get (&(RC)->ref_count) | | ------------------ | | #define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 55| 0|#define CAIRO_REFERENCE_COUNT_INVALID_VALUE ((int) -1) | | ------------------ | | | Branch (58:46): [True: 0, False: 0] | | ------------------ ------------------ 211| 1| { 212| 1| return device; 213| 1| } 214| | 215| 1| assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&device->ref_count)); ------------------ | Branch (215:5): [True: 0, False: 0] | Branch (215:5): [True: 0, False: 0] ------------------ 216| 0| _cairo_reference_count_inc (&device->ref_count); ------------------ | | 47| 0|#define _cairo_reference_count_inc(RC) _cairo_atomic_int_inc (&(RC)->ref_count) | | ------------------ | | | | 83| 0|# define _cairo_atomic_int_inc(x) ((void) atomic_fetch_add_explicit(x, 1, memory_order_seq_cst)) | | ------------------ ------------------ 217| | 218| 0| return device; 219| 0|} _cairo_error: 66| 311|{ 67| 311| CAIRO_ENSURE_UNIQUE; ------------------ | | 183| 311|#define CAIRO_ENSURE_UNIQUE do { } while (0) | | ------------------ | | | Branch (183:46): [Folded, False: 311] | | ------------------ ------------------ 68| 311| assert (_cairo_status_is_error (status)); ------------------ | Branch (68:5): [True: 0, False: 311] | Branch (68:5): [True: 0, False: 0] | Branch (68:5): [True: 311, False: 0] | Branch (68:5): [True: 311, False: 0] ------------------ 69| | 70| 311| return status; 71| 311|} _cairo_font_options_init_default: 73| 1|{ 74| 1| options->antialias = CAIRO_ANTIALIAS_DEFAULT; 75| 1| options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT; 76| 1| options->lcd_filter = CAIRO_LCD_FILTER_DEFAULT; 77| 1| options->hint_style = CAIRO_HINT_STYLE_DEFAULT; 78| 1| options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT; 79| 1| options->round_glyph_positions = CAIRO_ROUND_GLYPH_POS_DEFAULT; 80| 1| options->variations = NULL; 81| 1| options->color_mode = CAIRO_COLOR_MODE_DEFAULT; 82| 1| options->palette_index = CAIRO_COLOR_PALETTE_DEFAULT; ------------------ | | 1517| 1|#define CAIRO_COLOR_PALETTE_DEFAULT 0 ------------------ 83| | options->custom_palette = NULL; 84| 1| options->custom_palette_size = 0; 85| 1|} cairo_font_options_create: 159| 1|{ 160| 1| cairo_font_options_t *options; 161| | 162| 1| options = _cairo_calloc (sizeof (cairo_font_options_t)); ------------------ | | 79| 1| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 1, Folded] | | ------------------ ------------------ 163| 1| if (!options) { ------------------ | Branch (163:9): [True: 0, False: 1] ------------------ 164| 0| _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); ------------------ | | 126| 0|#define _cairo_error_throw(status) do { \ | | 127| 0| cairo_status_t status__ = _cairo_error (status); \ | | 128| 0| (void) status__; \ | | 129| 0|} while (0) | | ------------------ | | | Branch (129:10): [Folded, False: 0] | | ------------------ ------------------ 165| 0| return (cairo_font_options_t *) &_cairo_font_options_nil; 166| 0| } 167| | 168| 1| _cairo_font_options_init_default (options); 169| | 170| 1| return options; 171| 1|} _cairo_font_options_fini: 209| 1|{ 210| 1| free (options->variations); 211| 1| free (options->custom_palette); 212| 1|} cairo_font_options_destroy: 225| 1|{ 226| 1| if (cairo_font_options_status (options)) ------------------ | Branch (226:9): [True: 0, False: 1] ------------------ 227| 0| return; 228| | 229| 1| _cairo_font_options_fini (options); 230| 1| free (options); 231| 1|} cairo_font_options_status: 247| 1|{ 248| 1| if (options == NULL) ------------------ | Branch (248:9): [True: 0, False: 1] ------------------ 249| 0| return CAIRO_STATUS_NULL_POINTER; 250| 1| else if (options == (cairo_font_options_t *) &_cairo_font_options_nil) ------------------ | Branch (250:14): [True: 0, False: 1] ------------------ 251| 0| return CAIRO_STATUS_NO_MEMORY; 252| 1| else 253| 1| return CAIRO_STATUS_SUCCESS; 254| 1|} cairo-pattern.c:_freed_pool_get: 80| 42.9k|{ 81| 42.9k| void *ptr; 82| 42.9k| int i; 83| | 84| 42.9k| i = _cairo_atomic_int_get_relaxed (&pool->top) - 1; 85| 42.9k| if (i < 0) ------------------ | Branch (85:9): [True: 37.1k, False: 5.84k] ------------------ 86| 37.1k| i = 0; 87| | 88| 42.9k| ptr = _atomic_fetch (&pool->pool[i]); 89| 42.9k| if (likely (ptr != NULL)) { ------------------ | | 144| 42.9k|#define likely(expr) (__builtin_expect (!!(expr), 1)) | | ------------------ | | | Branch (144:22): [True: 5.84k, False: 37.1k] | | ------------------ ------------------ 90| 5.84k| _cairo_atomic_int_set_relaxed (&pool->top, i); 91| 5.84k| return ptr; 92| 5.84k| } 93| | 94| | /* either empty or contended */ 95| 37.1k| return _freed_pool_get_search (pool); 96| 42.9k|} cairo-pattern.c:_atomic_fetch: 59| 42.9k|{ 60| 42.9k| void *ptr; 61| | 62| 42.9k| do { 63| 42.9k| ptr = _cairo_atomic_ptr_get (slot); 64| 42.9k| } while (! _cairo_atomic_ptr_cmpxchg (slot, ptr, NULL)); ------------------ | | 121| 42.9k| _cairo_atomic_ptr_cmpxchg_impl(x, oldv, newv) ------------------ | Branch (64:14): [True: 0, False: 42.9k] ------------------ 65| | 66| 42.9k| return ptr; 67| 42.9k|} cairo-pattern.c:_freed_pool_put: 103| 42.9k|{ 104| 42.9k| int i; 105| | 106| 42.9k| i = _cairo_atomic_int_get_relaxed (&pool->top); 107| 42.9k| if (likely (i < ARRAY_LENGTH (pool->pool) && ------------------ | | 144| 48.8k|#define likely(expr) (__builtin_expect (!!(expr), 1)) | | ------------------ | | | Branch (144:22): [True: 5.90k, False: 37.0k] | | | Branch (144:44): [True: 5.90k, False: 37.0k] | | | Branch (144:44): [True: 5.90k, False: 0] | | ------------------ ------------------ 108| 42.9k| _atomic_store (&pool->pool[i], ptr))) 109| 5.90k| { 110| 5.90k| _cairo_atomic_int_set_relaxed (&pool->top, i + 1); 111| 5.90k| return; 112| 5.90k| } 113| | 114| | /* either full or contended */ 115| 37.0k| _freed_pool_put_search (pool, ptr); 116| 37.0k|} cairo-pattern.c:_atomic_store: 71| 5.90k|{ 72| 5.90k| return _cairo_atomic_ptr_cmpxchg (slot, NULL, ptr); ------------------ | | 121| 5.90k| _cairo_atomic_ptr_cmpxchg_impl(x, oldv, newv) ------------------ 73| 5.90k|} cairo-freed-pool.c:_atomic_fetch: 59| 594k|{ 60| 594k| void *ptr; 61| | 62| 594k| do { 63| 594k| ptr = _cairo_atomic_ptr_get (slot); 64| 594k| } while (! _cairo_atomic_ptr_cmpxchg (slot, ptr, NULL)); ------------------ | | 121| 594k| _cairo_atomic_ptr_cmpxchg_impl(x, oldv, newv) ------------------ | Branch (64:14): [True: 0, False: 594k] ------------------ 65| | 66| 594k| return ptr; 67| 594k|} cairo-freed-pool.c:_atomic_store: 71| 593k|{ 72| 593k| return _cairo_atomic_ptr_cmpxchg (slot, NULL, ptr); ------------------ | | 121| 593k| _cairo_atomic_ptr_cmpxchg_impl(x, oldv, newv) ------------------ 73| 593k|} _freed_pool_get_search: 46| 37.1k|{ 47| 37.1k| void *ptr; 48| 37.1k| int i; 49| | 50| 631k| for (i = ARRAY_LENGTH (pool->pool); i--;) { ------------------ | | 122| 37.1k|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (50:41): [True: 594k, False: 37.1k] ------------------ 51| 594k| ptr = _atomic_fetch (&pool->pool[i]); 52| 594k| if (ptr != NULL) { ------------------ | Branch (52:6): [True: 0, False: 594k] ------------------ 53| 0| _cairo_atomic_int_set_relaxed (&pool->top, i); 54| 0| return ptr; 55| 0| } 56| 594k| } 57| | 58| | /* empty */ 59| 37.1k| _cairo_atomic_int_set_relaxed (&pool->top, 0); 60| | return NULL; 61| 37.1k|} _freed_pool_put_search: 65| 37.0k|{ 66| 37.0k| int i; 67| | 68| 630k| for (i = 0; i < ARRAY_LENGTH (pool->pool); i++) { ------------------ | | 122| 630k|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (68:17): [True: 593k, False: 37.0k] ------------------ 69| 593k| if (_atomic_store (&pool->pool[i], ptr)) { ------------------ | Branch (69:6): [True: 0, False: 593k] ------------------ 70| 0| _cairo_atomic_int_set_relaxed (&pool->top, i + 1); 71| 0| return; 72| 0| } 73| 593k| } 74| | 75| | /* full */ 76| 37.0k| _cairo_atomic_int_set_relaxed (&pool->top, i); 77| 37.0k| free (ptr); 78| 37.0k|} cairo-pattern.c:cairo_list_init: 187| 42.9k|{ 188| 42.9k| entry->next = entry; 189| 42.9k| entry->prev = entry; 190| 42.9k|} cairo-recording-surface.c:cairo_list_init: 187| 1|{ 188| 1| entry->next = entry; 189| 1| entry->prev = entry; 190| 1|} cairo-surface.c:cairo_list_init: 187| 2|{ 188| 2| entry->next = entry; 189| 2| entry->prev = entry; 190| 2|} cairo-surface.c:cairo_list_is_empty: 345| 3|{ 346| 3| cairo_list_validate (head); 347| 3| return head->next == head; 348| 3|} cairo-array.c:_cairo_realloc_ab: 153| 3|{ 154| 3| size_t c; 155| 3| if (_cairo_mul_size_t_overflow (a, size, &c)) ------------------ | | 223| 3|#define _cairo_mul_size_t_overflow(a, b, c) __builtin_mul_overflow((size_t)(a), (size_t)(b), (size_t*)(c)) | | ------------------ | | | Branch (223:46): [True: 0, False: 3] | | ------------------ ------------------ 156| 0| return NULL; 157| | 158| 3| return realloc(ptr, c); 159| 3|} cairo_matrix_init_identity: 82| 43.3k|{ 83| 43.3k| cairo_matrix_init (matrix, 84| 43.3k| 1, 0, 85| 43.3k| 0, 1, 86| 43.3k| 0, 0); 87| 43.3k|} cairo_matrix_init: 115| 44.4k|{ 116| 44.4k| matrix->xx = xx; matrix->yx = yx; 117| 44.4k| matrix->xy = xy; matrix->yy = yy; 118| 44.4k| matrix->x0 = x0; matrix->y0 = y0; 119| 44.4k|} _cairo_matrix_get_affine: 146| 1|{ 147| 1| *xx = matrix->xx; 148| 1| *yx = matrix->yx; 149| | 150| 1| *xy = matrix->xy; 151| 1| *yy = matrix->yy; 152| | 153| 1| if (x0) ------------------ | Branch (153:9): [True: 1, False: 0] ------------------ 154| 1| *x0 = matrix->x0; 155| 1| if (y0) ------------------ | Branch (155:9): [True: 1, False: 0] ------------------ 156| 1| *y0 = matrix->y0; 157| 1|} cairo_matrix_init_translate: 173| 1|{ 174| 1| cairo_matrix_init (matrix, 175| 1| 1, 0, 176| 1| 0, 1, 177| 1| tx, ty); 178| 1|} cairo_matrix_translate: 195| 1|{ 196| 1| cairo_matrix_t tmp; 197| | 198| 1| cairo_matrix_init_translate (&tmp, tx, ty); 199| | 200| 1| cairo_matrix_multiply (matrix, &tmp, matrix); 201| 1|} cairo_matrix_init_rotate: 262| 1|{ 263| 1| double s; 264| 1| double c; 265| | 266| 1| s = sin (radians); 267| 1| c = cos (radians); 268| | 269| 1| cairo_matrix_init (matrix, 270| 1| c, s, 271| 1| -s, c, 272| 1| 0, 0); 273| 1|} cairo_matrix_rotate: 293| 1|{ 294| 1| cairo_matrix_t tmp; 295| | 296| 1| cairo_matrix_init_rotate (&tmp, radians); 297| | 298| 1| cairo_matrix_multiply (matrix, &tmp, matrix); 299| 1|} cairo_matrix_multiply: 325| 14|{ 326| 14| cairo_matrix_t r; 327| | 328| 14| r.xx = a->xx * b->xx + a->yx * b->xy; 329| 14| r.yx = a->xx * b->yx + a->yx * b->yy; 330| | 331| 14| r.xy = a->xy * b->xx + a->yy * b->xy; 332| 14| r.yy = a->xy * b->yx + a->yy * b->yy; 333| | 334| 14| r.x0 = a->x0 * b->xx + a->y0 * b->xy + b->x0; 335| 14| r.y0 = a->x0 * b->yx + a->y0 * b->yy + b->y0; 336| | 337| 14| *result = r; 338| 14|} cairo_matrix_invert: 572| 3|{ 573| 3| double det; 574| | 575| | /* Simple scaling|translation matrices are quite common... */ 576| 3| if (matrix->xy == 0. && matrix->yx == 0.) { ------------------ | Branch (576:9): [True: 2, False: 1] | Branch (576:29): [True: 2, False: 0] ------------------ 577| 2| matrix->x0 = -matrix->x0; 578| 2| matrix->y0 = -matrix->y0; 579| | 580| 2| if (matrix->xx != 1.) { ------------------ | Branch (580:6): [True: 0, False: 2] ------------------ 581| 0| if (matrix->xx == 0.) ------------------ | Branch (581:10): [True: 0, False: 0] ------------------ 582| 0| return _cairo_error (CAIRO_STATUS_INVALID_MATRIX); 583| | 584| 0| matrix->xx = 1. / matrix->xx; 585| 0| matrix->x0 *= matrix->xx; 586| 0| } 587| | 588| 2| if (matrix->yy != 1.) { ------------------ | Branch (588:6): [True: 0, False: 2] ------------------ 589| 0| if (matrix->yy == 0.) ------------------ | Branch (589:10): [True: 0, False: 0] ------------------ 590| 0| return _cairo_error (CAIRO_STATUS_INVALID_MATRIX); 591| | 592| 0| matrix->yy = 1. / matrix->yy; 593| 0| matrix->y0 *= matrix->yy; 594| 0| } 595| | 596| 2| return CAIRO_STATUS_SUCCESS; 597| 2| } 598| | 599| | /* inv (A) = 1/det (A) * adj (A) */ 600| 1| det = _cairo_matrix_compute_determinant (matrix); 601| | 602| 1| if (! ISFINITE (det)) ------------------ | | 96| 1|#define ISFINITE(x) isfinite (x) ------------------ | Branch (602:9): [True: 0, False: 1] ------------------ 603| 0| return _cairo_error (CAIRO_STATUS_INVALID_MATRIX); 604| | 605| 1| if (det == 0) ------------------ | Branch (605:9): [True: 0, False: 1] ------------------ 606| 0| return _cairo_error (CAIRO_STATUS_INVALID_MATRIX); 607| | 608| 1| _cairo_matrix_compute_adjoint (matrix); 609| 1| _cairo_matrix_scalar_multiply (matrix, 1 / det); 610| | 611| 1| return CAIRO_STATUS_SUCCESS; 612| 1|} _cairo_matrix_compute_determinant: 635| 1|{ 636| 1| double a, b, c, d; 637| | 638| 1| a = matrix->xx; b = matrix->yx; 639| 1| c = matrix->xy; d = matrix->yy; 640| | 641| 1| return a*d - b*c; 642| 1|} cairo-matrix.c:_cairo_matrix_compute_adjoint: 540| 1|{ 541| | /* adj (A) = transpose (C:cofactor (A,i,j)) */ 542| 1| double a, b, c, d, tx, ty; 543| | 544| 1| _cairo_matrix_get_affine (matrix, 545| 1| &a, &b, 546| 1| &c, &d, 547| 1| &tx, &ty); 548| | 549| 1| cairo_matrix_init (matrix, 550| 1| d, -b, 551| 1| -c, a, 552| 1| c*ty - d*tx, b*tx - a*ty); 553| 1|} cairo-matrix.c:_cairo_matrix_scalar_multiply: 523| 1|{ 524| 1| matrix->xx *= scalar; 525| 1| matrix->yx *= scalar; 526| | 527| 1| matrix->xy *= scalar; 528| 1| matrix->yy *= scalar; 529| | 530| 1| matrix->x0 *= scalar; 531| 1| matrix->y0 *= scalar; 532| 1|} _cairo_pattern_init: 212| 42.9k|{ 213| |#if HAVE_VALGRIND 214| | switch (type) { 215| | case CAIRO_PATTERN_TYPE_SOLID: 216| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_solid_pattern_t)); 217| | break; 218| | case CAIRO_PATTERN_TYPE_SURFACE: 219| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_surface_pattern_t)); 220| | break; 221| | case CAIRO_PATTERN_TYPE_LINEAR: 222| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_linear_pattern_t)); 223| | break; 224| | case CAIRO_PATTERN_TYPE_RADIAL: 225| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_radial_pattern_t)); 226| | break; 227| | case CAIRO_PATTERN_TYPE_MESH: 228| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_mesh_pattern_t)); 229| | break; 230| | case CAIRO_PATTERN_TYPE_RASTER_SOURCE: 231| | break; 232| | } 233| |#endif 234| | 235| 42.9k| pattern->type = type; 236| 42.9k| pattern->status = CAIRO_STATUS_SUCCESS; 237| | 238| | /* Set the reference count to zero for on-stack patterns. 239| | * Callers needs to explicitly increment the count for heap allocations. */ 240| 42.9k| CAIRO_REFERENCE_COUNT_INIT (&pattern->ref_count, 0); ------------------ | | 51| 42.9k|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 241| | 242| 42.9k| _cairo_user_data_array_init (&pattern->user_data); 243| | 244| 42.9k| if (type == CAIRO_PATTERN_TYPE_SURFACE || ------------------ | Branch (244:9): [True: 0, False: 42.9k] ------------------ 245| 42.9k| type == CAIRO_PATTERN_TYPE_RASTER_SOURCE) ------------------ | Branch (245:2): [True: 0, False: 42.9k] ------------------ 246| 0| pattern->extend = CAIRO_EXTEND_SURFACE_DEFAULT; ------------------ | | 668| 0|#define CAIRO_EXTEND_SURFACE_DEFAULT CAIRO_EXTEND_NONE ------------------ 247| 42.9k| else 248| 42.9k| pattern->extend = CAIRO_EXTEND_GRADIENT_DEFAULT; ------------------ | | 669| 42.9k|#define CAIRO_EXTEND_GRADIENT_DEFAULT CAIRO_EXTEND_PAD ------------------ 249| | 250| 42.9k| pattern->filter = CAIRO_FILTER_DEFAULT; ------------------ | | 670| 42.9k|#define CAIRO_FILTER_DEFAULT CAIRO_FILTER_GOOD ------------------ 251| 42.9k| pattern->opacity = 1.0; 252| | 253| 42.9k| pattern->has_component_alpha = FALSE; ------------------ | | 102| 42.9k|#define FALSE 0 ------------------ 254| 42.9k| pattern->is_foreground_marker = FALSE; ------------------ | | 102| 42.9k|#define FALSE 0 ------------------ 255| | 256| 42.9k| pattern->dither = CAIRO_DITHER_DEFAULT; 257| | 258| 42.9k| cairo_matrix_init_identity (&pattern->matrix); 259| | 260| 42.9k| cairo_list_init (&pattern->observers); 261| 42.9k|} _cairo_pattern_fini: 456| 42.9k|{ 457| 42.9k| _cairo_user_data_array_fini (&pattern->user_data); 458| | 459| 42.9k| switch (pattern->type) { ------------------ | Branch (459:13): [True: 42.9k, False: 0] ------------------ 460| 18.0k| case CAIRO_PATTERN_TYPE_SOLID: ------------------ | Branch (460:5): [True: 18.0k, False: 24.9k] ------------------ 461| 18.0k| break; 462| 0| case CAIRO_PATTERN_TYPE_SURFACE: { ------------------ | Branch (462:5): [True: 0, False: 42.9k] ------------------ 463| 0| cairo_surface_pattern_t *surface_pattern = 464| 0| (cairo_surface_pattern_t *) pattern; 465| | 466| 0| cairo_surface_destroy (surface_pattern->surface); 467| 0| } break; 468| 10.4k| case CAIRO_PATTERN_TYPE_LINEAR: ------------------ | Branch (468:5): [True: 10.4k, False: 32.5k] ------------------ 469| 24.1k| case CAIRO_PATTERN_TYPE_RADIAL: { ------------------ | Branch (469:5): [True: 13.7k, False: 29.2k] ------------------ 470| 24.1k| cairo_gradient_pattern_t *gradient = 471| 24.1k| (cairo_gradient_pattern_t *) pattern; 472| | 473| 24.1k| if (gradient->stops && gradient->stops != gradient->stops_embedded) ------------------ | Branch (473:6): [True: 0, False: 24.1k] | Branch (473:25): [True: 0, False: 0] ------------------ 474| 0| free (gradient->stops); 475| 24.1k| } break; 476| 763| case CAIRO_PATTERN_TYPE_MESH: { ------------------ | Branch (476:5): [True: 763, False: 42.2k] ------------------ 477| 763| cairo_mesh_pattern_t *mesh = 478| 763| (cairo_mesh_pattern_t *) pattern; 479| | 480| 763| _cairo_array_fini (&mesh->patches); 481| 763| } break; 482| 0| case CAIRO_PATTERN_TYPE_RASTER_SOURCE: ------------------ | Branch (482:5): [True: 0, False: 42.9k] ------------------ 483| 0| _cairo_raster_source_pattern_finish (pattern); 484| 0| break; 485| 42.9k| } 486| | 487| |#if HAVE_VALGRIND 488| | switch (pattern->type) { 489| | case CAIRO_PATTERN_TYPE_SOLID: 490| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_solid_pattern_t)); 491| | break; 492| | case CAIRO_PATTERN_TYPE_SURFACE: 493| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_surface_pattern_t)); 494| | break; 495| | case CAIRO_PATTERN_TYPE_LINEAR: 496| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_linear_pattern_t)); 497| | break; 498| | case CAIRO_PATTERN_TYPE_RADIAL: 499| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_radial_pattern_t)); 500| | break; 501| | case CAIRO_PATTERN_TYPE_MESH: 502| | VALGRIND_MAKE_MEM_UNDEFINED (pattern, sizeof (cairo_mesh_pattern_t)); 503| | break; 504| | case CAIRO_PATTERN_TYPE_RASTER_SOURCE: 505| | break; 506| | } 507| |#endif 508| 42.9k|} _cairo_pattern_init_solid: 560| 18.0k|{ 561| 18.0k| _cairo_pattern_init (&pattern->base, CAIRO_PATTERN_TYPE_SOLID); 562| 18.0k| pattern->color = *color; 563| 18.0k|} _cairo_pattern_create_solid: 622| 18.0k|{ 623| 18.0k| cairo_solid_pattern_t *pattern; 624| | 625| 18.0k| pattern = 626| 18.0k| _freed_pool_get (&freed_pattern_pool[CAIRO_PATTERN_TYPE_SOLID]); 627| 18.0k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 18.0k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 16.8k, False: 1.14k] | | ------------------ ------------------ 628| | /* None cached, need to create a new pattern. */ 629| 16.8k| pattern = _cairo_calloc (sizeof (cairo_solid_pattern_t)); ------------------ | | 79| 16.8k| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 16.8k, Folded] | | ------------------ ------------------ 630| 16.8k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 16.8k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 16.8k] | | ------------------ ------------------ 631| 0| _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); ------------------ | | 126| 0|#define _cairo_error_throw(status) do { \ | | 127| 0| cairo_status_t status__ = _cairo_error (status); \ | | 128| 0| (void) status__; \ | | 129| 0|} while (0) | | ------------------ | | | Branch (129:10): [Folded, False: 0] | | ------------------ ------------------ 632| 0| return (cairo_pattern_t *) &_cairo_pattern_nil; 633| 0| } 634| 16.8k| } 635| | 636| 18.0k| _cairo_pattern_init_solid (pattern, color); 637| 18.0k| CAIRO_REFERENCE_COUNT_INIT (&pattern->base.ref_count, 1); ------------------ | | 51| 18.0k|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 638| | 639| 18.0k| return &pattern->base; 640| 18.0k|} cairo_pattern_create_rgb: 691| 16|{ 692| 16| return cairo_pattern_create_rgba (red, green, blue, 1.0); 693| 16|} cairo_pattern_create_rgba: 723| 18.0k|{ 724| 18.0k| cairo_color_t color; 725| | 726| 18.0k| red = _cairo_restrict_value (red, 0.0, 1.0); 727| 18.0k| green = _cairo_restrict_value (green, 0.0, 1.0); 728| 18.0k| blue = _cairo_restrict_value (blue, 0.0, 1.0); 729| 18.0k| alpha = _cairo_restrict_value (alpha, 0.0, 1.0); 730| | 731| 18.0k| _cairo_color_init_rgba (&color, red, green, blue, alpha); 732| | 733| 18.0k| CAIRO_MUTEX_INITIALIZE (); ------------------ | | 173| 18.0k|#define CAIRO_MUTEX_INITIALIZE CAIRO_MUTEX_IMPL_INITIALIZE | | ------------------ | | | | 88| 18.0k|# define CAIRO_MUTEX_IMPL_INITIALIZE() CAIRO_MUTEX_IMPL_NOOP | | | | ------------------ | | | | | | 53| 18.0k|#define CAIRO_MUTEX_IMPL_NOOP do {/*no-op*/} while (0) | | | | | | ------------------ | | | | | | | Branch (53:53): [Folded, False: 18.0k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 734| | 735| 18.0k| return _cairo_pattern_create_solid (&color); 736| 18.0k|} cairo_pattern_create_linear: 816| 10.4k|{ 817| 10.4k| cairo_linear_pattern_t *pattern; 818| | 819| 10.4k| pattern = 820| 10.4k| _freed_pool_get (&freed_pattern_pool[CAIRO_PATTERN_TYPE_LINEAR]); 821| 10.4k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 10.4k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 9.50k, False: 970] | | ------------------ ------------------ 822| 9.50k| pattern = _cairo_calloc (sizeof (cairo_linear_pattern_t)); ------------------ | | 79| 9.50k| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 9.50k, Folded] | | ------------------ ------------------ 823| 9.50k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 9.50k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 9.50k] | | ------------------ ------------------ 824| 0| _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); ------------------ | | 126| 0|#define _cairo_error_throw(status) do { \ | | 127| 0| cairo_status_t status__ = _cairo_error (status); \ | | 128| 0| (void) status__; \ | | 129| 0|} while (0) | | ------------------ | | | Branch (129:10): [Folded, False: 0] | | ------------------ ------------------ 825| 0| return (cairo_pattern_t *) &_cairo_pattern_nil.base; 826| 0| } 827| 9.50k| } 828| | 829| 10.4k| CAIRO_MUTEX_INITIALIZE (); ------------------ | | 173| 10.4k|#define CAIRO_MUTEX_INITIALIZE CAIRO_MUTEX_IMPL_INITIALIZE | | ------------------ | | | | 88| 10.4k|# define CAIRO_MUTEX_IMPL_INITIALIZE() CAIRO_MUTEX_IMPL_NOOP | | | | ------------------ | | | | | | 53| 10.4k|#define CAIRO_MUTEX_IMPL_NOOP do {/*no-op*/} while (0) | | | | | | ------------------ | | | | | | | Branch (53:53): [Folded, False: 10.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 830| | 831| 10.4k| _cairo_pattern_init_linear (pattern, x0, y0, x1, y1); 832| 10.4k| CAIRO_REFERENCE_COUNT_INIT (&pattern->base.base.ref_count, 1); ------------------ | | 51| 10.4k|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 833| | 834| 10.4k| return &pattern->base.base; 835| 10.4k|} cairo_pattern_create_radial: 870| 13.7k|{ 871| 13.7k| cairo_radial_pattern_t *pattern; 872| | 873| 13.7k| pattern = 874| 13.7k| _freed_pool_get (&freed_pattern_pool[CAIRO_PATTERN_TYPE_RADIAL]); 875| 13.7k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 13.7k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 10.3k, False: 3.39k] | | ------------------ ------------------ 876| 10.3k| pattern = _cairo_calloc (sizeof (cairo_radial_pattern_t)); ------------------ | | 79| 10.3k| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 10.3k, Folded] | | ------------------ ------------------ 877| 10.3k| if (unlikely (pattern == NULL)) { ------------------ | | 145| 10.3k|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 10.3k] | | ------------------ ------------------ 878| 0| _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); ------------------ | | 126| 0|#define _cairo_error_throw(status) do { \ | | 127| 0| cairo_status_t status__ = _cairo_error (status); \ | | 128| 0| (void) status__; \ | | 129| 0|} while (0) | | ------------------ | | | Branch (129:10): [Folded, False: 0] | | ------------------ ------------------ 879| 0| return (cairo_pattern_t *) &_cairo_pattern_nil.base; 880| 0| } 881| 10.3k| } 882| | 883| 13.7k| CAIRO_MUTEX_INITIALIZE (); ------------------ | | 173| 13.7k|#define CAIRO_MUTEX_INITIALIZE CAIRO_MUTEX_IMPL_INITIALIZE | | ------------------ | | | | 88| 13.7k|# define CAIRO_MUTEX_IMPL_INITIALIZE() CAIRO_MUTEX_IMPL_NOOP | | | | ------------------ | | | | | | 53| 13.7k|#define CAIRO_MUTEX_IMPL_NOOP do {/*no-op*/} while (0) | | | | | | ------------------ | | | | | | | Branch (53:53): [Folded, False: 13.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 884| | 885| 13.7k| _cairo_pattern_init_radial (pattern, cx0, cy0, radius0, cx1, cy1, radius1); 886| 13.7k| CAIRO_REFERENCE_COUNT_INIT (&pattern->base.base.ref_count, 1); ------------------ | | 51| 13.7k|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 887| | 888| 13.7k| return &pattern->base.base; 889| 13.7k|} cairo_pattern_create_mesh: 1048| 763|{ 1049| 763| cairo_mesh_pattern_t *pattern; 1050| | 1051| 763| pattern = 1052| 763| _freed_pool_get (&freed_pattern_pool[CAIRO_PATTERN_TYPE_MESH]); 1053| 763| if (unlikely (pattern == NULL)) { ------------------ | | 145| 763|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 434, False: 329] | | ------------------ ------------------ 1054| 434| pattern = _cairo_calloc (sizeof (cairo_mesh_pattern_t)); ------------------ | | 79| 434| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 434, Folded] | | ------------------ ------------------ 1055| 434| if (unlikely (pattern == NULL)) { ------------------ | | 145| 434|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 434] | | ------------------ ------------------ 1056| 0| _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); ------------------ | | 126| 0|#define _cairo_error_throw(status) do { \ | | 127| 0| cairo_status_t status__ = _cairo_error (status); \ | | 128| 0| (void) status__; \ | | 129| 0|} while (0) | | ------------------ | | | Branch (129:10): [Folded, False: 0] | | ------------------ ------------------ 1057| 0| return (cairo_pattern_t *) &_cairo_pattern_nil.base; 1058| 0| } 1059| 434| } 1060| | 1061| 763| CAIRO_MUTEX_INITIALIZE (); ------------------ | | 173| 763|#define CAIRO_MUTEX_INITIALIZE CAIRO_MUTEX_IMPL_INITIALIZE | | ------------------ | | | | 88| 763|# define CAIRO_MUTEX_IMPL_INITIALIZE() CAIRO_MUTEX_IMPL_NOOP | | | | ------------------ | | | | | | 53| 763|#define CAIRO_MUTEX_IMPL_NOOP do {/*no-op*/} while (0) | | | | | | ------------------ | | | | | | | Branch (53:53): [Folded, False: 763] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1062| | 1063| 763| _cairo_pattern_init (&pattern->base, CAIRO_PATTERN_TYPE_MESH); 1064| 763| _cairo_array_init (&pattern->patches, sizeof (cairo_mesh_patch_t)); 1065| 763| pattern->current_patch = NULL; 1066| 763| CAIRO_REFERENCE_COUNT_INIT (&pattern->base.ref_count, 1); ------------------ | | 51| 763|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 1067| | 1068| 763| return &pattern->base; 1069| 763|} cairo_pattern_reference: 1088| 21|{ 1089| 21| if (pattern == NULL || ------------------ | Branch (1089:9): [True: 0, False: 21] ------------------ 1090| 21| CAIRO_REFERENCE_COUNT_IS_INVALID (&pattern->ref_count)) ------------------ | | 58| 21|#define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 53| 21|#define CAIRO_REFERENCE_COUNT_GET_VALUE(RC) _cairo_atomic_int_get (&(RC)->ref_count) | | ------------------ | | #define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 55| 21|#define CAIRO_REFERENCE_COUNT_INVALID_VALUE ((int) -1) | | ------------------ | | | Branch (58:46): [True: 0, False: 21] | | ------------------ ------------------ 1091| 0| return pattern; 1092| | 1093| 21| assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&pattern->ref_count)); ------------------ | Branch (1093:5): [True: 0, False: 21] | Branch (1093:5): [True: 21, False: 0] ------------------ 1094| | 1095| 21| _cairo_reference_count_inc (&pattern->ref_count); ------------------ | | 47| 21|#define _cairo_reference_count_inc(RC) _cairo_atomic_int_inc (&(RC)->ref_count) | | ------------------ | | | | 83| 21|# define _cairo_atomic_int_inc(x) ((void) atomic_fetch_add_explicit(x, 1, memory_order_seq_cst)) | | ------------------ ------------------ 1096| | 1097| 21| return pattern; 1098| 21|} cairo_pattern_destroy: 1148| 43.0k|{ 1149| 43.0k| cairo_pattern_type_t type; 1150| | 1151| 43.0k| if (pattern == NULL || ------------------ | Branch (1151:9): [True: 0, False: 43.0k] ------------------ 1152| 43.0k| CAIRO_REFERENCE_COUNT_IS_INVALID (&pattern->ref_count)) ------------------ | | 58| 43.0k|#define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 53| 43.0k|#define CAIRO_REFERENCE_COUNT_GET_VALUE(RC) _cairo_atomic_int_get (&(RC)->ref_count) | | ------------------ | | #define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 55| 43.0k|#define CAIRO_REFERENCE_COUNT_INVALID_VALUE ((int) -1) | | ------------------ | | | Branch (58:46): [True: 0, False: 43.0k] | | ------------------ ------------------ 1153| 0| return; 1154| | 1155| 43.0k| assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&pattern->ref_count)); ------------------ | Branch (1155:5): [True: 0, False: 43.0k] | Branch (1155:5): [True: 43.0k, False: 0] ------------------ 1156| | 1157| 43.0k| if (! _cairo_reference_count_dec_and_test (&pattern->ref_count)) ------------------ | | 49| 43.0k|#define _cairo_reference_count_dec_and_test(RC) _cairo_atomic_int_dec_and_test (&(RC)->ref_count) | | ------------------ | | | | 85| 43.0k|# define _cairo_atomic_int_dec_and_test(x) (atomic_fetch_sub_explicit(x, 1, memory_order_seq_cst) == 1) | | ------------------ ------------------ | Branch (1157:9): [True: 21, False: 42.9k] ------------------ 1158| 21| return; 1159| | 1160| 42.9k| type = pattern->type; 1161| 42.9k| _cairo_pattern_fini (pattern); 1162| | 1163| | /* maintain a small cache of freed patterns */ 1164| 42.9k| if (type < ARRAY_LENGTH (freed_pattern_pool)) ------------------ | | 122| 42.9k|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (1164:9): [True: 42.9k, False: 0] ------------------ 1165| 42.9k| _freed_pool_put (&freed_pattern_pool[type], pattern); 1166| 0| else 1167| 0| free (pattern); 1168| 42.9k|} cairo_mesh_pattern_begin_patch: 1267| 4|{ 1268| 4| cairo_mesh_pattern_t *mesh; 1269| 4| cairo_status_t status; 1270| 4| cairo_mesh_patch_t *current_patch; 1271| 4| int i; 1272| | 1273| 4| if (unlikely (pattern->status)) ------------------ | | 145| 4|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 4] | | ------------------ ------------------ 1274| 0| return; 1275| | 1276| 4| if (unlikely (pattern->type != CAIRO_PATTERN_TYPE_MESH)) { ------------------ | | 145| 4|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 1, False: 3] | | ------------------ ------------------ 1277| 1| _cairo_pattern_set_error (pattern, CAIRO_STATUS_PATTERN_TYPE_MISMATCH); 1278| 1| return; 1279| 1| } 1280| | 1281| 3| mesh = (cairo_mesh_pattern_t *) pattern; 1282| 3| if (unlikely (mesh->current_patch)) { ------------------ | | 145| 3|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 3] | | ------------------ ------------------ 1283| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1284| 0| return; 1285| 0| } 1286| | 1287| 3| status = _cairo_array_allocate (&mesh->patches, 1, (void **) ¤t_patch); 1288| 3| if (unlikely (status)) { ------------------ | | 145| 3|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 3] | | ------------------ ------------------ 1289| 0| _cairo_pattern_set_error (pattern, status); 1290| 0| return; 1291| 0| } 1292| | 1293| 3| mesh->current_patch = current_patch; 1294| 3| mesh->current_side = -2; /* no current point */ 1295| | 1296| 15| for (i = 0; i < 4; i++) ------------------ | Branch (1296:17): [True: 12, False: 3] ------------------ 1297| 12| mesh->has_control_point[i] = FALSE; ------------------ | | 102| 15|#define FALSE 0 ------------------ 1298| | 1299| 15| for (i = 0; i < 4; i++) ------------------ | Branch (1299:17): [True: 12, False: 3] ------------------ 1300| 12| mesh->has_color[i] = FALSE; ------------------ | | 102| 15|#define FALSE 0 ------------------ 1301| 3|} cairo_mesh_pattern_end_patch: 1367| 1|{ 1368| 1| cairo_mesh_pattern_t *mesh; 1369| 1| cairo_mesh_patch_t *current_patch; 1370| 1| int i; 1371| | 1372| 1| if (unlikely (pattern->status)) ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 1] | | ------------------ ------------------ 1373| 0| return; 1374| | 1375| 1| if (unlikely (pattern->type != CAIRO_PATTERN_TYPE_MESH)) { ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 1] | | ------------------ ------------------ 1376| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_PATTERN_TYPE_MISMATCH); 1377| 0| return; 1378| 0| } 1379| | 1380| 1| mesh = (cairo_mesh_pattern_t *) pattern; 1381| 1| current_patch = mesh->current_patch; 1382| 1| if (unlikely (!current_patch)) { ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 1, False: 0] | | ------------------ ------------------ 1383| 1| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1384| 1| return; 1385| 1| } 1386| | 1387| 0| if (unlikely (mesh->current_side == -2)) { ------------------ | | 145| 0|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 0] | | ------------------ ------------------ 1388| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1389| 0| return; 1390| 0| } 1391| | 1392| 0| while (mesh->current_side < 3) { ------------------ | Branch (1392:12): [True: 0, False: 0] ------------------ 1393| 0| int corner_num; 1394| | 1395| 0| cairo_mesh_pattern_line_to (pattern, 1396| 0| current_patch->points[0][0].x, 1397| 0| current_patch->points[0][0].y); 1398| | 1399| 0| corner_num = mesh->current_side + 1; 1400| 0| if (corner_num < 4 && ! mesh->has_color[corner_num]) { ------------------ | Branch (1400:6): [True: 0, False: 0] | Branch (1400:24): [True: 0, False: 0] ------------------ 1401| 0| current_patch->colors[corner_num] = current_patch->colors[0]; 1402| 0| mesh->has_color[corner_num] = TRUE; ------------------ | | 106| 0|#define TRUE 1 ------------------ 1403| 0| } 1404| 0| } 1405| | 1406| 0| for (i = 0; i < 4; i++) { ------------------ | Branch (1406:17): [True: 0, False: 0] ------------------ 1407| 0| if (! mesh->has_control_point[i]) ------------------ | Branch (1407:6): [True: 0, False: 0] ------------------ 1408| 0| _calc_control_point (current_patch, i); 1409| 0| } 1410| | 1411| 0| for (i = 0; i < 4; i++) { ------------------ | Branch (1411:17): [True: 0, False: 0] ------------------ 1412| 0| if (! mesh->has_color[i]) ------------------ | Branch (1412:6): [True: 0, False: 0] ------------------ 1413| 0| current_patch->colors[i] = *CAIRO_COLOR_TRANSPARENT; ------------------ | | 799| 0|#define CAIRO_COLOR_TRANSPARENT _cairo_stock_color (CAIRO_STOCK_TRANSPARENT) ------------------ 1414| 0| } 1415| | 1416| | mesh->current_patch = NULL; 1417| 0|} cairo_mesh_pattern_curve_to: 1454| 1|{ 1455| 1| cairo_mesh_pattern_t *mesh; 1456| 1| int current_point, i, j; 1457| | 1458| 1| if (unlikely (pattern->status)) ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 1] | | ------------------ ------------------ 1459| 0| return; 1460| | 1461| 1| if (unlikely (pattern->type != CAIRO_PATTERN_TYPE_MESH)) { ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 1, False: 0] | | ------------------ ------------------ 1462| 1| _cairo_pattern_set_error (pattern, CAIRO_STATUS_PATTERN_TYPE_MISMATCH); 1463| 1| return; 1464| 1| } 1465| | 1466| 0| mesh = (cairo_mesh_pattern_t *) pattern; 1467| 0| if (unlikely (!mesh->current_patch)) { ------------------ | | 145| 0|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 0] | | ------------------ ------------------ 1468| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1469| 0| return; 1470| 0| } 1471| | 1472| 0| if (unlikely (mesh->current_side == 3)) { ------------------ | | 145| 0|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 0] | | ------------------ ------------------ 1473| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1474| 0| return; 1475| 0| } 1476| | 1477| 0| if (mesh->current_side == -2) ------------------ | Branch (1477:9): [True: 0, False: 0] ------------------ 1478| 0| cairo_mesh_pattern_move_to (pattern, x1, y1); 1479| | 1480| 0| assert (mesh->current_side >= -1); ------------------ | Branch (1480:5): [True: 0, False: 0] | Branch (1480:5): [True: 0, False: 0] ------------------ 1481| 0| assert (pattern->status == CAIRO_STATUS_SUCCESS); ------------------ | Branch (1481:5): [True: 0, False: 0] | Branch (1481:5): [True: 0, False: 0] ------------------ 1482| | 1483| 0| mesh->current_side++; 1484| | 1485| 0| current_point = 3 * mesh->current_side; 1486| | 1487| 0| current_point++; 1488| 0| i = mesh_path_point_i[current_point]; 1489| 0| j = mesh_path_point_j[current_point]; 1490| 0| mesh->current_patch->points[i][j].x = x1; 1491| 0| mesh->current_patch->points[i][j].y = y1; 1492| | 1493| 0| current_point++; 1494| 0| i = mesh_path_point_i[current_point]; 1495| 0| j = mesh_path_point_j[current_point]; 1496| 0| mesh->current_patch->points[i][j].x = x2; 1497| 0| mesh->current_patch->points[i][j].y = y2; 1498| | 1499| 0| current_point++; 1500| 0| if (current_point < 12) { ------------------ | Branch (1500:9): [True: 0, False: 0] ------------------ 1501| 0| i = mesh_path_point_i[current_point]; 1502| 0| j = mesh_path_point_j[current_point]; 1503| 0| mesh->current_patch->points[i][j].x = x3; 1504| 0| mesh->current_patch->points[i][j].y = y3; 1505| 0| } 1506| 0|} cairo_mesh_pattern_line_to: 1535| 2|{ 1536| 2| cairo_mesh_pattern_t *mesh; 1537| 2| cairo_point_double_t last_point; 1538| 2| int last_point_idx, i, j; 1539| | 1540| 2| if (unlikely (pattern->status)) ------------------ | | 145| 2|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 2] | | ------------------ ------------------ 1541| 0| return; 1542| | 1543| 2| if (unlikely (pattern->type != CAIRO_PATTERN_TYPE_MESH)) { ------------------ | | 145| 2|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 1, False: 1] | | ------------------ ------------------ 1544| 1| _cairo_pattern_set_error (pattern, CAIRO_STATUS_PATTERN_TYPE_MISMATCH); 1545| 1| return; 1546| 1| } 1547| | 1548| 1| mesh = (cairo_mesh_pattern_t *) pattern; 1549| 1| if (unlikely (!mesh->current_patch)) { ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 1, False: 0] | | ------------------ ------------------ 1550| 1| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1551| 1| return; 1552| 1| } 1553| | 1554| 0| if (unlikely (mesh->current_side == 3)) { ------------------ | | 145| 0|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 0] | | ------------------ ------------------ 1555| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1556| 0| return; 1557| 0| } 1558| | 1559| 0| if (mesh->current_side == -2) { ------------------ | Branch (1559:9): [True: 0, False: 0] ------------------ 1560| 0| cairo_mesh_pattern_move_to (pattern, x, y); 1561| 0| return; 1562| 0| } 1563| | 1564| 0| last_point_idx = 3 * (mesh->current_side + 1); 1565| 0| i = mesh_path_point_i[last_point_idx]; 1566| 0| j = mesh_path_point_j[last_point_idx]; 1567| | 1568| 0| last_point = mesh->current_patch->points[i][j]; 1569| | 1570| 0| cairo_mesh_pattern_curve_to (pattern, 1571| 0| (2 * last_point.x + x) * (1. / 3), 1572| 0| (2 * last_point.y + y) * (1. / 3), 1573| 0| (last_point.x + 2 * x) * (1. / 3), 1574| 0| (last_point.y + 2 * y) * (1. / 3), 1575| 0| x, y); 1576| 0|} cairo_mesh_pattern_move_to: 1600| 362|{ 1601| 362| cairo_mesh_pattern_t *mesh; 1602| | 1603| 362| if (unlikely (pattern->status)) ------------------ | | 145| 362|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 56, False: 306] | | ------------------ ------------------ 1604| 56| return; 1605| | 1606| 306| if (unlikely (pattern->type != CAIRO_PATTERN_TYPE_MESH)) { ------------------ | | 145| 306|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 294, False: 12] | | ------------------ ------------------ 1607| 294| _cairo_pattern_set_error (pattern, CAIRO_STATUS_PATTERN_TYPE_MISMATCH); 1608| 294| return; 1609| 294| } 1610| | 1611| 12| mesh = (cairo_mesh_pattern_t *) pattern; 1612| 12| if (unlikely (!mesh->current_patch)) { ------------------ | | 145| 12|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 12, False: 0] | | ------------------ ------------------ 1613| 12| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1614| 12| return; 1615| 12| } 1616| | 1617| 0| if (unlikely (mesh->current_side >= 0)) { ------------------ | | 145| 0|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 0] | | ------------------ ------------------ 1618| 0| _cairo_pattern_set_error (pattern, CAIRO_STATUS_INVALID_MESH_CONSTRUCTION); 1619| 0| return; 1620| 0| } 1621| | 1622| 0| mesh->current_side = -1; 1623| 0| mesh->current_patch->points[0][0].x = x; 1624| 0| mesh->current_patch->points[0][0].y = y; 1625| 0|} cairo_pattern_set_matrix: 2025| 2|{ 2026| 2| cairo_matrix_t inverse; 2027| 2| cairo_status_t status; 2028| | 2029| 2| if (pattern->status) ------------------ | Branch (2029:9): [True: 0, False: 2] ------------------ 2030| 0| return; 2031| | 2032| 2| if (memcmp (&pattern->matrix, matrix, sizeof (cairo_matrix_t)) == 0) ------------------ | Branch (2032:9): [True: 0, False: 2] ------------------ 2033| 0| return; 2034| | 2035| 2| pattern->matrix = *matrix; 2036| 2| _cairo_pattern_notify_observers (pattern, CAIRO_PATTERN_NOTIFY_MATRIX); 2037| | 2038| 2| inverse = *matrix; 2039| 2| status = cairo_matrix_invert (&inverse); 2040| 2| if (unlikely (status)) ------------------ | | 145| 2|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 2] | | ------------------ ------------------ 2041| 0| status = _cairo_pattern_set_error (pattern, status); 2042| 2|} cairo_pattern_get_matrix: 2055| 2|{ 2056| 2| *matrix = pattern->matrix; 2057| 2|} cairo_pattern_set_filter: 2083| 1|{ 2084| 1| if (pattern->status) ------------------ | Branch (2084:9): [True: 0, False: 1] ------------------ 2085| 0| return; 2086| | 2087| 1| pattern->filter = filter; 2088| 1| _cairo_pattern_notify_observers (pattern, CAIRO_PATTERN_NOTIFY_FILTER); 2089| 1|} cairo_pattern_set_extend: 2164| 1|{ 2165| 1| if (pattern->status) ------------------ | Branch (2165:9): [True: 0, False: 1] ------------------ 2166| 0| return; 2167| | 2168| 1| pattern->extend = extend; 2169| 1| _cairo_pattern_notify_observers (pattern, CAIRO_PATTERN_NOTIFY_EXTEND); 2170| 1|} cairo-pattern.c:_cairo_pattern_set_error: 199| 311|{ 200| 311| if (status == CAIRO_STATUS_SUCCESS) ------------------ | Branch (200:9): [True: 0, False: 311] ------------------ 201| 0| return status; 202| | 203| | /* Don't overwrite an existing error. This preserves the first 204| | * error, which is the most significant. */ 205| 311| _cairo_status_set_error (&pattern->status, status); ------------------ | | 477| 311|#define _cairo_status_set_error(status, err) do { \ | | 478| 311| int ret__; \ | | 479| 311| assert (err < CAIRO_STATUS_LAST_STATUS); \ | | 480| 311| assert (sizeof(*status) == sizeof(cairo_atomic_int_t)); \ | | 481| 311| /* hide compiler warnings about cairo_status_t != int (gcc treats its as \ | | 482| 311| * an unsigned integer instead, and about ignoring the return value. */ \ | | 483| 311| ret__ = _cairo_atomic_int_cmpxchg ((cairo_atomic_int_t *) status, CAIRO_STATUS_SUCCESS, err); \ | | ------------------ | | | | 98| 311| _cairo_atomic_int_cmpxchg_impl(x, oldv, newv) | | ------------------ | | 484| 311| (void) ret__; \ | | 485| 311|} while (0) | | ------------------ | | | Branch (485:10): [Folded, False: 311] | | ------------------ ------------------ | Branch (205:5): [True: 0, False: 311] | Branch (205:5): [True: 311, False: 0] | Branch (205:5): [True: 0, Folded] | Branch (205:5): [True: 311, Folded] ------------------ 206| | 207| 311| return _cairo_error (status); 208| 311|} cairo-pattern.c:_cairo_pattern_init_linear: 596| 10.4k|{ 597| 10.4k| _cairo_pattern_init_gradient (&pattern->base, CAIRO_PATTERN_TYPE_LINEAR); 598| | 599| 10.4k| pattern->pd1.x = x0; 600| 10.4k| pattern->pd1.y = y0; 601| 10.4k| pattern->pd2.x = x1; 602| 10.4k| pattern->pd2.y = y1; 603| 10.4k|} cairo-pattern.c:_cairo_pattern_init_gradient: 585| 24.1k|{ 586| 24.1k| _cairo_pattern_init (&pattern->base, type); 587| | 588| 24.1k| pattern->n_stops = 0; 589| 24.1k| pattern->stops_size = 0; 590| | pattern->stops = NULL; 591| 24.1k|} cairo-pattern.c:_cairo_pattern_init_radial: 609| 13.7k|{ 610| 13.7k| _cairo_pattern_init_gradient (&pattern->base, CAIRO_PATTERN_TYPE_RADIAL); 611| | 612| 13.7k| pattern->cd1.center.x = cx0; 613| 13.7k| pattern->cd1.center.y = cy0; 614| 13.7k| pattern->cd1.radius = fabs (radius0); 615| 13.7k| pattern->cd2.center.x = cx1; 616| 13.7k| pattern->cd2.center.y = cy1; 617| 13.7k| pattern->cd2.radius = fabs (radius1); 618| 13.7k|} cairo-pattern.c:_cairo_pattern_notify_observers: 172| 4|{ 173| 4| cairo_pattern_observer_t *pos; 174| | 175| 4| cairo_list_foreach_entry (pos, cairo_pattern_observer_t, &pattern->observers, link) ------------------ | | 79| 4| for (pos = cairo_list_entry((head)->next, type, member);\ | | ------------------ | | | | 51| 4| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 4|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 4| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 4| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 4|}) | | | | ------------------ | | ------------------ | | 80| 4| &pos->member != (head); \ | | ------------------ | | | Branch (80:7): [True: 0, False: 4] | | ------------------ | | 81| 4| pos = cairo_list_entry(pos->member.next, type, member)) | | ------------------ | | | | 51| 0| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 0|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 0| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 0| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 0|}) | | | | ------------------ | | ------------------ ------------------ 176| 0| pos->notify (pos, pattern, flags); 177| 4|} cairo_recording_surface_create: 399| 1|{ 400| 1| cairo_recording_surface_t *surface; 401| | 402| 1| surface = _cairo_calloc (sizeof (cairo_recording_surface_t)); ------------------ | | 79| 1| ((size) != 0 ? calloc(1,size) : NULL) | | ------------------ | | | Branch (79:6): [True: 1, Folded] | | ------------------ ------------------ 403| 1| if (unlikely (surface == NULL)) ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 1] | | ------------------ ------------------ 404| 0| return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); 405| | 406| 1| _cairo_surface_init (&surface->base, 407| 1| &cairo_recording_surface_backend, 408| 1| NULL, /* device */ 409| 1| content, 410| 1| TRUE); /* is_vector */ ------------------ | | 106| 1|#define TRUE 1 ------------------ 411| | 412| | 413| 1| surface->unbounded = TRUE; ------------------ | | 106| 1|#define TRUE 1 ------------------ 414| | 415| | /* unbounded -> 'infinite' extents */ 416| 1| if (extents != NULL) { ------------------ | Branch (416:9): [True: 0, False: 1] ------------------ 417| 0| surface->extents_pixels = *extents; 418| | 419| | /* XXX check for overflow */ 420| 0| surface->extents.x = floor (extents->x); 421| 0| surface->extents.y = floor (extents->y); 422| 0| surface->extents.width = ceil (extents->x + extents->width) - surface->extents.x; 423| 0| surface->extents.height = ceil (extents->y + extents->height) - surface->extents.y; 424| | 425| 0| surface->unbounded = FALSE; ------------------ | | 102| 0|#define FALSE 0 ------------------ 426| 0| } 427| | 428| 1| _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); 429| | 430| 1| surface->base.is_clear = TRUE; ------------------ | | 106| 1|#define TRUE 1 ------------------ 431| | 432| 1| surface->bbtree.left = surface->bbtree.right = NULL; 433| 1| surface->bbtree.chain = INVALID_CHAIN; ------------------ | | 166| 1|#define INVALID_CHAIN ((cairo_command_header_t *)-1) ------------------ 434| | 435| 1| surface->indices = NULL; 436| 1| surface->num_indices = 0; 437| 1| surface->optimize_clears = TRUE; ------------------ | | 106| 1|#define TRUE 1 ------------------ 438| 1| surface->has_bilevel_alpha = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 439| 1| surface->has_only_op_over = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 440| 1| surface->has_tags = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 441| | 442| 1| CAIRO_MUTEX_INIT (surface->mutex); ------------------ | | 178| 1|#define CAIRO_MUTEX_INIT CAIRO_MUTEX_IMPL_INIT | | ------------------ | | | | 92| 1|# define CAIRO_MUTEX_IMPL_INIT(mutex) do { \ | | | | 93| 1| cairo_mutex_t _tmp_mutex = CAIRO_MUTEX_IMPL_NIL_INITIALIZER; \ | | | | ------------------ | | | | | | 217| 1|# define CAIRO_MUTEX_IMPL_NIL_INITIALIZER PTHREAD_MUTEX_INITIALIZER | | | | ------------------ | | | | 94| 1| memcpy (&(mutex), &_tmp_mutex, sizeof (_tmp_mutex)); \ | | | | 95| 1| } while (0) | | | | ------------------ | | | | | Branch (95:12): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 443| | 444| 1| cairo_list_init (&surface->region_array_list); 445| | 446| 1| return &surface->base; 447| 1|} cairo-recording-surface.c:_cairo_recording_surface_finish: 610| 1|{ 611| 1| cairo_recording_surface_t *surface = abstract_surface; 612| | 613| 1| _cairo_recording_surface_reset (surface); 614| 1| CAIRO_MUTEX_FINI (surface->mutex); ------------------ | | 179| 1|#define CAIRO_MUTEX_FINI CAIRO_MUTEX_IMPL_FINI | | ------------------ | | | | 213| 1|# define CAIRO_MUTEX_IMPL_FINI(mutex) pthread_mutex_destroy (&(mutex)) | | ------------------ ------------------ 615| | 616| 1| return CAIRO_STATUS_SUCCESS; 617| 1|} cairo-recording-surface.c:_cairo_recording_surface_reset: 526| 1|{ 527| 1| cairo_command_t **elements; 528| 1| int i, num_elements; 529| 1| cairo_recording_regions_array_t *region_array, *region_next; 530| | 531| | /* Normally backend surfaces hold a reference to the surface as 532| | * well as the region and free the region before the surface. So 533| | * the regions should already be freed at this point but just in 534| | * case we ensure the regions are freed before destroying the 535| | * surface. */ 536| 1| cairo_list_foreach_entry_safe (region_array, region_next, ------------------ | | 113| 1| for (pos = cairo_list_entry ((head)->next, type, member),\ | | ------------------ | | | | 51| 1| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 1|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 1| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 1| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 1|}) | | | | ------------------ | | ------------------ | | 114| 1| n = cairo_list_entry (pos->member.next, type, member);\ | | ------------------ | | | | 51| 1| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 1|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 1| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 1| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 1|}) | | | | ------------------ | | ------------------ | | 115| 1| &pos->member != (head); \ | | ------------------ | | | Branch (115:7): [True: 0, False: 1] | | ------------------ | | 116| 1| pos = n, n = cairo_list_entry (n->member.next, type, member)) | | ------------------ | | | | 51| 0| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 0|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 0| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 0| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 0|}) | | | | ------------------ | | ------------------ ------------------ 537| 1| cairo_recording_regions_array_t, 538| 1| &surface->region_array_list, link) 539| 0| { 540| 0| cairo_list_del (®ion_array->link); 541| 0| _cairo_recording_surface_region_array_destroy (surface, region_array); 542| 0| } 543| | 544| 1| num_elements = surface->commands.num_elements; 545| 1| elements = _cairo_array_index (&surface->commands, 0); 546| 1| for (i = 0; i < num_elements; i++) { ------------------ | Branch (546:17): [True: 0, False: 1] ------------------ 547| 0| cairo_command_t *command = elements[i]; 548| | 549| 0| switch (command->header.type) { 550| 0| case CAIRO_COMMAND_PAINT: ------------------ | Branch (550:2): [True: 0, False: 0] ------------------ 551| 0| _cairo_pattern_fini (&command->paint.source.base); 552| 0| break; 553| | 554| 0| case CAIRO_COMMAND_MASK: ------------------ | Branch (554:2): [True: 0, False: 0] ------------------ 555| 0| _cairo_pattern_fini (&command->mask.source.base); 556| 0| _cairo_pattern_fini (&command->mask.mask.base); 557| 0| break; 558| | 559| 0| case CAIRO_COMMAND_STROKE: ------------------ | Branch (559:2): [True: 0, False: 0] ------------------ 560| 0| _cairo_pattern_fini (&command->stroke.source.base); 561| 0| _cairo_path_fixed_fini (&command->stroke.path); 562| 0| _cairo_stroke_style_fini (&command->stroke.style); 563| 0| break; 564| | 565| 0| case CAIRO_COMMAND_FILL: ------------------ | Branch (565:2): [True: 0, False: 0] ------------------ 566| 0| _cairo_pattern_fini (&command->fill.source.base); 567| 0| _cairo_path_fixed_fini (&command->fill.path); 568| 0| break; 569| | 570| 0| case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: ------------------ | Branch (570:2): [True: 0, False: 0] ------------------ 571| 0| _cairo_pattern_fini (&command->show_text_glyphs.source.base); 572| 0| free (command->show_text_glyphs.utf8); 573| 0| free (command->show_text_glyphs.glyphs); 574| 0| free (command->show_text_glyphs.clusters); 575| 0| cairo_scaled_font_destroy (command->show_text_glyphs.scaled_font); 576| 0| break; 577| | 578| 0| case CAIRO_COMMAND_TAG: ------------------ | Branch (578:2): [True: 0, False: 0] ------------------ 579| 0| free (command->tag.tag_name); 580| 0| if (command->tag.begin) { ------------------ | Branch (580:10): [True: 0, False: 0] ------------------ 581| 0| free (command->tag.attributes); 582| 0| } 583| 0| break; 584| | 585| 0| default: ------------------ | Branch (585:6): [True: 0, False: 0] ------------------ 586| 0| ASSERT_NOT_REACHED; ------------------ | | 140| 0|#define ASSERT_NOT_REACHED \ | | 141| 0|do { \ | | 142| 0| assert (!"reached"); \ | | 143| 0|} while (0) | | ------------------ | | | Branch (143:10): [Folded, False: 0] | | ------------------ ------------------ | Branch (586:6): [Folded, False: 0] | Branch (586:6): [Folded, False: 0] ------------------ 587| 0| } 588| | 589| 0| _cairo_clip_destroy (command->header.clip); 590| 0| free (command); 591| 0| } 592| | 593| 1| _cairo_array_fini (&surface->commands); 594| 1| _cairo_array_init (&surface->commands, sizeof (cairo_command_t *)); 595| | 596| 1| if (surface->bbtree.left) ------------------ | Branch (596:9): [True: 0, False: 1] ------------------ 597| 0| bbtree_del (surface->bbtree.left); 598| 1| if (surface->bbtree.right) ------------------ | Branch (598:9): [True: 0, False: 1] ------------------ 599| 0| bbtree_del (surface->bbtree.right); 600| 1| surface->bbtree.left = surface->bbtree.right = NULL; 601| 1| surface->bbtree.chain = INVALID_CHAIN; ------------------ | | 166| 1|#define INVALID_CHAIN ((cairo_command_header_t *)-1) ------------------ 602| | 603| 1| free (surface->indices); 604| | surface->indices = NULL; 605| 1| surface->num_indices = 0; 606| 1|} cairo-surface.c:__cairo_surface_flush: 45| 1|{ 46| 1| cairo_status_t status = CAIRO_STATUS_SUCCESS; 47| 1| if (surface->backend->flush) ------------------ | Branch (47:9): [True: 0, False: 1] ------------------ 48| 0| status = surface->backend->flush (surface, flags); 49| 1| return status; 50| 1|} _cairo_surface_init: 412| 1|{ 413| 1| CAIRO_MUTEX_INITIALIZE (); ------------------ | | 173| 1|#define CAIRO_MUTEX_INITIALIZE CAIRO_MUTEX_IMPL_INITIALIZE | | ------------------ | | | | 88| 1|# define CAIRO_MUTEX_IMPL_INITIALIZE() CAIRO_MUTEX_IMPL_NOOP | | | | ------------------ | | | | | | 53| 1|#define CAIRO_MUTEX_IMPL_NOOP do {/*no-op*/} while (0) | | | | | | ------------------ | | | | | | | Branch (53:53): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 414| | 415| 1| surface->backend = backend; 416| 1| surface->device = cairo_device_reference (device); 417| 1| surface->content = content; 418| 1| surface->type = backend->type; 419| 1| surface->is_vector = is_vector; 420| | 421| 1| CAIRO_REFERENCE_COUNT_INIT (&surface->ref_count, 1); ------------------ | | 51| 1|#define CAIRO_REFERENCE_COUNT_INIT(RC, VALUE) ((RC)->ref_count = (VALUE)) ------------------ 422| 1| surface->status = CAIRO_STATUS_SUCCESS; 423| 1| surface->unique_id = _cairo_surface_allocate_unique_id (); 424| 1| surface->finished = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 425| 1| surface->_finishing = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 426| 1| surface->is_clear = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 427| 1| surface->serial = 0; 428| 1| surface->damage = NULL; 429| 1| surface->owns_device = (device != NULL); 430| | 431| 1| _cairo_user_data_array_init (&surface->user_data); 432| 1| _cairo_user_data_array_init (&surface->mime_data); 433| | 434| 1| cairo_matrix_init_identity (&surface->device_transform); 435| 1| cairo_matrix_init_identity (&surface->device_transform_inverse); 436| 1| cairo_list_init (&surface->device_transform_observers); 437| | 438| 1| surface->x_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; ------------------ | | 731| 1|#define CAIRO_SURFACE_RESOLUTION_DEFAULT 72.0 ------------------ 439| 1| surface->y_resolution = CAIRO_SURFACE_RESOLUTION_DEFAULT; ------------------ | | 731| 1|#define CAIRO_SURFACE_RESOLUTION_DEFAULT 72.0 ------------------ 440| | 441| 1| surface->x_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; ------------------ | | 732| 1|#define CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT 300.0 ------------------ 442| 1| surface->y_fallback_resolution = CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT; ------------------ | | 732| 1|#define CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT 300.0 ------------------ 443| | 444| 1| cairo_list_init (&surface->snapshots); 445| 1| surface->snapshot_of = NULL; 446| | 447| 1| surface->has_font_options = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 448| | 449| 1| surface->foreground_source = NULL; 450| 1| surface->foreground_used = FALSE; ------------------ | | 102| 1|#define FALSE 0 ------------------ 451| 1|} cairo_surface_destroy: 958| 1|{ 959| 1| if (surface == NULL || ------------------ | Branch (959:9): [True: 0, False: 1] ------------------ 960| 1| CAIRO_REFERENCE_COUNT_IS_INVALID (&surface->ref_count)) ------------------ | | 58| 1|#define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 53| 1|#define CAIRO_REFERENCE_COUNT_GET_VALUE(RC) _cairo_atomic_int_get (&(RC)->ref_count) | | ------------------ | | #define CAIRO_REFERENCE_COUNT_IS_INVALID(RC) (CAIRO_REFERENCE_COUNT_GET_VALUE (RC) == CAIRO_REFERENCE_COUNT_INVALID_VALUE) | | ------------------ | | | | 55| 1|#define CAIRO_REFERENCE_COUNT_INVALID_VALUE ((int) -1) | | ------------------ | | | Branch (58:46): [True: 0, False: 1] | | ------------------ ------------------ 961| 0| return; 962| | 963| 1| assert (CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)); ------------------ | Branch (963:5): [True: 0, False: 1] | Branch (963:5): [True: 1, False: 0] ------------------ 964| | 965| 1| if (! _cairo_reference_count_dec_and_test (&surface->ref_count)) ------------------ | | 49| 1|#define _cairo_reference_count_dec_and_test(RC) _cairo_atomic_int_dec_and_test (&(RC)->ref_count) | | ------------------ | | | | 85| 1|# define _cairo_atomic_int_dec_and_test(x) (atomic_fetch_sub_explicit(x, 1, memory_order_seq_cst) == 1) | | ------------------ ------------------ | Branch (965:9): [True: 0, False: 1] ------------------ 966| 0| return; 967| | 968| 1| assert (surface->snapshot_of == NULL); ------------------ | Branch (968:5): [True: 0, False: 1] | Branch (968:5): [True: 1, False: 0] ------------------ 969| | 970| 1| if (! surface->finished) { ------------------ | Branch (970:9): [True: 1, False: 0] ------------------ 971| 1| _cairo_surface_finish_snapshots (surface); 972| | /* We may have been referenced by a snapshot prior to have 973| | * detaching it with the copy-on-write. 974| | */ 975| 1| if (CAIRO_REFERENCE_COUNT_GET_VALUE (&surface->ref_count)) ------------------ | | 53| 1|#define CAIRO_REFERENCE_COUNT_GET_VALUE(RC) _cairo_atomic_int_get (&(RC)->ref_count) | | ------------------ | | | Branch (53:45): [True: 0, False: 1] | | ------------------ ------------------ 976| 0| return; 977| | 978| 1| _cairo_surface_finish (surface); 979| 1| } 980| | 981| 1| if (surface->damage) ------------------ | Branch (981:9): [True: 0, False: 1] ------------------ 982| 0| _cairo_damage_destroy (surface->damage); 983| | 984| 1| _cairo_user_data_array_fini (&surface->user_data); 985| 1| _cairo_user_data_array_fini (&surface->mime_data); 986| | 987| 1| if (surface->foreground_source) ------------------ | Branch (987:9): [True: 0, False: 1] ------------------ 988| 0| cairo_pattern_destroy (surface->foreground_source); 989| | 990| 1| if (surface->owns_device) ------------------ | Branch (990:9): [True: 0, False: 1] ------------------ 991| 0| cairo_device_destroy (surface->device); 992| | 993| 1| if (surface->has_font_options) ------------------ | Branch (993:9): [True: 0, False: 1] ------------------ 994| 0| _cairo_font_options_fini (&surface->font_options); 995| | 996| 1| assert (surface->snapshot_of == NULL); ------------------ | Branch (996:5): [True: 0, False: 1] | Branch (996:5): [True: 1, False: 0] ------------------ 997| 1| assert (! _cairo_surface_has_snapshots (surface)); ------------------ | Branch (997:5): [True: 0, False: 1] | Branch (997:5): [True: 1, False: 0] ------------------ 998| | /* paranoid check that nobody took a reference whilst finishing */ 999| 1| assert (! CAIRO_REFERENCE_COUNT_HAS_REFERENCE (&surface->ref_count)); ------------------ | Branch (999:5): [True: 0, False: 1] | Branch (999:5): [True: 1, False: 0] ------------------ 1000| | 1001| 1| free (surface); 1002| 1|} _cairo_surface_flush: 1632| 1|{ 1633| | /* update the current snapshots *before* the user updates the surface */ 1634| 1| _cairo_surface_detach_snapshots (surface); 1635| 1| if (surface->snapshot_of != NULL) ------------------ | Branch (1635:9): [True: 0, False: 1] ------------------ 1636| 0| _cairo_surface_detach_snapshot (surface); 1637| 1| _cairo_surface_detach_mime_data (surface); 1638| | 1639| 1| return __cairo_surface_flush (surface, flags); 1640| 1|} cairo-surface.c:_cairo_surface_allocate_unique_id: 272| 1|{ 273| 1| static cairo_atomic_int_t unique_id; 274| | 275| |#if CAIRO_NO_MUTEX 276| | if (++unique_id == 0) 277| | unique_id = 1; 278| | return unique_id; 279| |#else 280| 1| int old, id; 281| | 282| 1| do { 283| 1| old = _cairo_atomic_uint_get (&unique_id); ------------------ | | 473| 1|#define _cairo_atomic_uint_get(x) _cairo_atomic_int_get(x) ------------------ 284| 1| id = old + 1; 285| 1| if (id == 0) ------------------ | Branch (285:6): [True: 0, False: 1] ------------------ 286| 0| id = 1; 287| 1| } while (! _cairo_atomic_uint_cmpxchg (&unique_id, old, id)); ------------------ | | 475| 1| _cairo_atomic_int_cmpxchg((cairo_atomic_int_t *)x, oldv, newv) | | ------------------ | | | | 98| 1| _cairo_atomic_int_cmpxchg_impl(x, oldv, newv) | | ------------------ ------------------ | Branch (287:14): [True: 0, False: 1] ------------------ 288| | 289| 1| return id; 290| 1|#endif 291| 1|} cairo-surface.c:_cairo_surface_has_snapshots: 316| 3|{ 317| 3| return ! cairo_list_is_empty (&surface->snapshots); 318| 3|} cairo-surface.c:_cairo_surface_finish_snapshots: 1027| 1|{ 1028| 1| cairo_status_t status; 1029| | 1030| | /* update the snapshots *before* we declare the surface as finished */ 1031| 1| surface->_finishing = TRUE; ------------------ | | 106| 1|#define TRUE 1 ------------------ 1032| 1| status = _cairo_surface_flush (surface, 0); 1033| 1| (void) status; 1034| 1|} cairo-surface.c:_cairo_surface_finish: 1038| 1|{ 1039| 1| cairo_status_t status; 1040| | 1041| | /* call finish even if in error mode */ 1042| 1| if (surface->backend->finish) { ------------------ | Branch (1042:9): [True: 1, False: 0] ------------------ 1043| 1| status = surface->backend->finish (surface); 1044| 1| if (unlikely (status)) ------------------ | | 145| 1|#define unlikely(expr) (__builtin_expect (!!(expr), 0)) | | ------------------ | | | Branch (145:24): [True: 0, False: 1] | | ------------------ ------------------ 1045| 0| _cairo_surface_set_error (surface, status); 1046| 1| } 1047| | 1048| 1| surface->finished = TRUE; ------------------ | | 106| 1|#define TRUE 1 ------------------ 1049| | 1050| 1| assert (surface->snapshot_of == NULL); ------------------ | Branch (1050:5): [True: 0, False: 1] | Branch (1050:5): [True: 1, False: 0] ------------------ 1051| 1| assert (!_cairo_surface_has_snapshots (surface)); ------------------ | Branch (1051:5): [True: 0, False: 1] | Branch (1051:5): [True: 1, False: 0] ------------------ 1052| 1|} cairo-surface.c:_cairo_surface_detach_snapshots: 338| 1|{ 339| 1| while (_cairo_surface_has_snapshots (surface)) { ------------------ | Branch (339:12): [True: 0, False: 1] ------------------ 340| | _cairo_surface_detach_snapshot (cairo_list_first_entry (&surface->snapshots, ------------------ | | 54| 0| cairo_list_entry((ptr)->next, type, member) | | ------------------ | | | | 51| 0| cairo_container_of(ptr, type, member) | | | | ------------------ | | | | | | 130| 0|#define cairo_container_of(ptr, type, member) ({ \ | | | | | | 131| 0| const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \ | | | | | | 132| 0| (type *) ((char *) mptr__ - offsetof (type, member)); \ | | | | | | 133| 0|}) | | | | ------------------ | | ------------------ ------------------ 341| 0| cairo_surface_t, 342| 0| snapshot)); 343| 0| } 344| 1|} cairo-surface.c:_cairo_surface_detach_mime_data: 328| 1|{ 329| 1| if (! _cairo_surface_has_mime_data (surface)) ------------------ | Branch (329:9): [True: 1, False: 0] ------------------ 330| 1| return; 331| | 332| 0| _cairo_user_data_array_fini (&surface->mime_data); 333| 0| _cairo_user_data_array_init (&surface->mime_data); 334| 0|} cairo-surface.c:_cairo_surface_has_mime_data: 322| 1|{ 323| 1| return surface->mime_data.num_elements != 0; 324| 1|} cairo-pattern.c:_cairo_restrict_value: 748| 72.0k|{ 749| 72.0k| if (value < min) ------------------ | Branch (749:9): [True: 350, False: 71.7k] ------------------ 750| 350| return min; 751| 71.7k| else if (value > max) ------------------ | Branch (751:14): [True: 9.68k, False: 62.0k] ------------------ 752| 9.68k| return max; 753| 62.0k| else 754| 62.0k| return value; 755| 72.0k|} csi_file_new_for_bytes: 129| 5.14k|{ 130| 5.14k| csi_file_t *file; 131| | 132| 5.14k| file = _csi_slab_alloc (ctx, sizeof (csi_file_t)); 133| 5.14k| if (file == NULL) ------------------ | Branch (133:9): [True: 0, False: 5.14k] ------------------ 134| 0| return _csi_error (CAIRO_STATUS_NO_MEMORY); 135| | 136| 5.14k| file->base.type = CSI_OBJECT_TYPE_FILE; 137| 5.14k| file->base.ref = 1; 138| | 139| 5.14k| file->type = BYTES; 140| 5.14k| file->src = (uint8_t *) bytes; 141| 5.14k| file->data = (uint8_t *) bytes; 142| 5.14k| file->bp = (uint8_t *) bytes; 143| 5.14k| file->rem = length; 144| | 145| 5.14k| obj->type = CSI_OBJECT_TYPE_FILE; 146| 5.14k| obj->datum.file = file; 147| 5.14k| return CAIRO_STATUS_SUCCESS; 148| 5.14k|} _csi_file_execute: 822| 5.14k|{ 823| 5.14k| return _csi_scan_file (ctx, obj); 824| 5.14k|} csi_file_getc: 828| 40.2M|{ 829| 40.2M| int c; 830| | 831| 40.2M| if (_csi_unlikely (file->src == NULL)) ------------------ | | 120| 40.2M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 40.2M| __extension__ ({ \ | | | | 112| 40.2M| int _csi_boolean_var_; \ | | | | 113| 40.2M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 40.2M] | | | | ------------------ | | | | 114| 40.2M| _csi_boolean_var_ = 1; \ | | | | 115| 40.2M| else \ | | | | 116| 40.2M| _csi_boolean_var_ = 0; \ | | | | 117| 40.2M| _csi_boolean_var_; \ | | | | 118| 40.2M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 40.2M] | | ------------------ ------------------ 832| 0| return EOF; 833| | 834| 40.2M| switch (file->type) { 835| 0| case STDIO: ------------------ | Branch (835:5): [True: 0, False: 40.2M] ------------------ 836| 0| if (_csi_likely (file->rem)) { ------------------ | | 119| 0|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (119:27): [True: 0, False: 0] | | ------------------ ------------------ 837| 0| c = *file->bp++; 838| 0| file->rem--; 839| 0| } else { 840| 0| file->rem = fread (file->bp = file->data, 1, CHUNK_SIZE, file->src); ------------------ | | 48| 0|#define CHUNK_SIZE 32768 ------------------ 841| | /* fall through */ 842| 40.2M| case BYTES: ------------------ | Branch (842:5): [True: 40.2M, False: 0] ------------------ 843| 40.2M| if (_csi_likely (file->rem)) { ------------------ | | 119| 40.2M|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 40.2M| __extension__ ({ \ | | | | 112| 40.2M| int _csi_boolean_var_; \ | | | | 113| 40.2M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 40.2M, False: 3.35k] | | | | ------------------ | | | | 114| 40.2M| _csi_boolean_var_ = 1; \ | | | | 115| 40.2M| else \ | | | | 116| 40.2M| _csi_boolean_var_ = 0; \ | | | | 117| 40.2M| _csi_boolean_var_; \ | | | | 118| 40.2M|}) | | ------------------ | | | Branch (119:27): [True: 40.2M, False: 3.35k] | | ------------------ ------------------ 844| 40.2M| c = *file->bp++; 845| 40.2M| file->rem--; 846| 40.2M| } else 847| 3.35k| c = EOF; 848| 40.2M| } 849| 40.2M| break; 850| | 851| 40.2M| case PROCEDURE: ------------------ | Branch (851:5): [True: 0, False: 40.2M] ------------------ 852| |#if 0 853| | if (file->data == NULL) { 854| | csi_status_t status; 855| | csi_object_t *string; 856| | 857| |RERUN_PROCEDURE: 858| | status = csi_object_execute (file->src); 859| | if (status) 860| | return EOF; 861| | 862| | string = csi_pop_operand (file->base.ctx); 863| | if (string == NULL) 864| | return EOF; 865| | file->data = csi_object_as_file (file->base.ctx, string); 866| | csi_object_free (string); 867| | if (file->data == NULL) 868| | return EOF; 869| | } 870| | c = csi_file_getc (file->data); 871| | if (c == EOF) { 872| | csi_object_free (file->data); 873| | file->data = NULL; 874| | goto RERUN_PROCEDURE; 875| | } 876| |#else 877| 0| c = EOF; 878| 0|#endif 879| 0| break; 880| | 881| 0| case FILTER: ------------------ | Branch (881:5): [True: 0, False: 40.2M] ------------------ 882| 0| c = file->filter->filter_getc (file); 883| 0| break; 884| | 885| 0| default: ------------------ | Branch (885:5): [True: 0, False: 40.2M] ------------------ 886| 0| c = EOF; 887| 0| break; 888| 40.2M| } 889| | 890| 40.2M| return c; 891| 40.2M|} csi_file_read: 895| 1.33M|{ 896| 1.33M| int ret; 897| | 898| 1.33M| if (file->src == NULL) ------------------ | Branch (898:9): [True: 0, False: 1.33M] ------------------ 899| 0| return 0; 900| | 901| 1.33M| switch (file->type) { 902| 0| case STDIO: ------------------ | Branch (902:5): [True: 0, False: 1.33M] ------------------ 903| 0| if (file->rem > 0) { ------------------ | Branch (903:6): [True: 0, False: 0] ------------------ 904| 0| ret = len; 905| 0| if (file->rem < ret) ------------------ | Branch (905:10): [True: 0, False: 0] ------------------ 906| 0| ret = file->rem; 907| 0| memcpy (buf, file->bp, ret); 908| 0| file->bp += ret; 909| 0| file->rem -= ret; 910| 0| } else 911| 0| ret = fread (buf, 1, len, file->src); 912| 0| break; 913| | 914| 1.33M| case BYTES: ------------------ | Branch (914:5): [True: 1.33M, False: 0] ------------------ 915| 1.33M| if (file->rem > 0) { ------------------ | Branch (915:6): [True: 1.33M, False: 506] ------------------ 916| 1.33M| ret = len; 917| 1.33M| if (file->rem < ret) ------------------ | Branch (917:10): [True: 270, False: 1.33M] ------------------ 918| 270| ret = file->rem; 919| 1.33M| memcpy (buf, file->bp, ret); 920| 1.33M| file->bp += ret; 921| 1.33M| file->rem -= ret; 922| 1.33M| } else 923| 506| ret = 0; 924| 1.33M| break; 925| | 926| 0| case PROCEDURE: ------------------ | Branch (926:5): [True: 0, False: 1.33M] ------------------ 927| |#if 0 928| | if (file->data == NULL) { 929| | csi_status_t status; 930| | csi_object_t *string; 931| | 932| |RERUN_PROCEDURE: 933| | status = csi_object_execute (file->src); 934| | if (status) 935| | return 0; 936| | 937| | string = csi_pop_operand (file->base.ctx); 938| | if (string == NULL) 939| | return 0; 940| | file->data = csi_object_as_file (file->base.ctx, string); 941| | csi_object_free (string); 942| | if (file->data == NULL) 943| | return 0; 944| | } 945| | ret = csi_file_read (file->data, buf, len); 946| | if (ret == 0) { 947| | csi_object_free (file->data); 948| | file->data = NULL; 949| | goto RERUN_PROCEDURE; 950| | } 951| |#else 952| 0| ret = 0; 953| 0|#endif 954| 0| break; 955| | 956| 0| case FILTER: ------------------ | Branch (956:5): [True: 0, False: 1.33M] ------------------ 957| 0| ret = file->filter->filter_read (file, buf, len); 958| 0| break; 959| | 960| 0| default: ------------------ | Branch (960:5): [True: 0, False: 1.33M] ------------------ 961| 0| ret = 0; 962| 0| break; 963| 1.33M| } 964| | 965| 1.33M| return ret; 966| 1.33M|} csi_file_putc: 970| 224k|{ 971| 224k| if (file->src == NULL) ------------------ | Branch (971:9): [True: 0, False: 224k] ------------------ 972| 0| return; 973| | 974| 224k| switch ((int) file->type) { 975| 0| case STDIO: ------------------ | Branch (975:5): [True: 0, False: 224k] ------------------ 976| 224k| case BYTES: ------------------ | Branch (976:5): [True: 224k, False: 0] ------------------ 977| 224k| file->bp--; 978| 224k| file->rem++; 979| 224k| break; 980| 0| case FILTER: ------------------ | Branch (980:5): [True: 0, False: 224k] ------------------ 981| 0| file->filter->filter_putc (file, c); 982| 0| break; 983| 0| default: ------------------ | Branch (983:5): [True: 0, False: 224k] ------------------ 984| 0| break; 985| 224k| } 986| 224k|} csi_file_flush: 990| 5.14k|{ 991| 5.14k| if (file->src == NULL) ------------------ | Branch (991:9): [True: 0, False: 5.14k] ------------------ 992| 0| return; 993| | 994| 5.14k| switch ((int) file->type) { 995| 0| case FILTER: /* need to eat EOD */ ------------------ | Branch (995:5): [True: 0, False: 5.14k] ------------------ 996| 0| while (csi_file_getc (file) != EOF) ------------------ | Branch (996:9): [True: 0, False: 0] ------------------ 997| 0| ; 998| 0| break; 999| 5.14k| default: ------------------ | Branch (999:5): [True: 5.14k, False: 0] ------------------ 1000| 5.14k| break; 1001| 5.14k| } 1002| 5.14k|} csi_file_close: 1006| 5.14k|{ 1007| 5.14k| if (file->src == NULL) ------------------ | Branch (1007:9): [True: 0, False: 5.14k] ------------------ 1008| 0| return; 1009| | 1010| 5.14k| switch (file->type) { 1011| 0| case STDIO: ------------------ | Branch (1011:5): [True: 0, False: 5.14k] ------------------ 1012| 0| if (file->flags & OWN_STREAM) ------------------ | | 50| 0|#define OWN_STREAM 0x1 ------------------ | Branch (1012:6): [True: 0, False: 0] ------------------ 1013| 0| fclose (file->src); 1014| 0| break; 1015| 5.14k| case BYTES: ------------------ | Branch (1015:5): [True: 5.14k, False: 0] ------------------ 1016| 5.14k| if (file->src != file->data) { ------------------ | Branch (1016:6): [True: 0, False: 5.14k] ------------------ 1017| 0| csi_string_t *src = file->src; 1018| 0| if (src != NULL && --src->base.ref == 0) ------------------ | Branch (1018:10): [True: 0, False: 0] | Branch (1018:25): [True: 0, False: 0] ------------------ 1019| 0| csi_string_free (ctx, src); 1020| 0| } 1021| 5.14k| break; 1022| 0| case FILTER: ------------------ | Branch (1022:5): [True: 0, False: 5.14k] ------------------ 1023| 0| { 1024| 0| csi_file_t *src = file->src; 1025| 0| if (src != NULL && --src->base.ref == 0) ------------------ | Branch (1025:10): [True: 0, False: 0] | Branch (1025:25): [True: 0, False: 0] ------------------ 1026| 0| _csi_file_free (ctx, src); 1027| 0| } 1028| 0| break; 1029| 0| case PROCEDURE: ------------------ | Branch (1029:5): [True: 0, False: 5.14k] ------------------ 1030| 0| default: ------------------ | Branch (1030:5): [True: 0, False: 5.14k] ------------------ 1031| 0| break; 1032| 5.14k| } 1033| 5.14k| file->src = NULL; 1034| 5.14k|} _csi_file_free: 1038| 5.14k|{ 1039| 5.14k| csi_file_flush (file); 1040| | /* XXX putback */ 1041| 5.14k| csi_file_close (ctx, file); 1042| | 1043| 5.14k| switch (file->type) { 1044| 5.14k| case BYTES: ------------------ | Branch (1044:5): [True: 5.14k, False: 0] ------------------ 1045| 5.14k| break; 1046| 0| case PROCEDURE: ------------------ | Branch (1046:5): [True: 0, False: 5.14k] ------------------ 1047| |#if 0 1048| | csi_object_free (ctx, file->data); 1049| |#endif 1050| 0| break; 1051| 0| case STDIO: ------------------ | Branch (1051:5): [True: 0, False: 5.14k] ------------------ 1052| 0| _csi_free (ctx, file->data); 1053| 0| break; 1054| 0| case FILTER: ------------------ | Branch (1054:5): [True: 0, False: 5.14k] ------------------ 1055| 0| file->filter->filter_destroy (ctx, file->data); 1056| 0| break; 1057| 0| default: ------------------ | Branch (1057:5): [True: 0, False: 5.14k] ------------------ 1058| 0| break; 1059| 5.14k| } 1060| | 1061| 5.14k| _csi_slab_free (ctx, file, sizeof (csi_file_t)); 1062| 5.14k|} _csi_hash_table_init: 128| 96.0k|{ 129| 96.0k| hash_table->keys_equal = keys_equal; 130| | 131| 96.0k| hash_table->arrangement = &hash_table_arrangements[0]; 132| | 133| 96.0k| hash_table->entries = calloc (hash_table->arrangement->size, 134| 96.0k| sizeof(csi_hash_entry_t *)); 135| 96.0k| if (hash_table->entries == NULL) ------------------ | Branch (135:9): [True: 0, False: 96.0k] ------------------ 136| 0| return _csi_error (CAIRO_STATUS_NO_MEMORY); 137| | 138| 96.0k| hash_table->live_entries = 0; 139| 96.0k| hash_table->used_entries = 0; 140| 96.0k| hash_table->iterating = 0; 141| | 142| 96.0k| return CSI_STATUS_SUCCESS; 143| 96.0k|} _csi_hash_table_fini: 164| 96.0k|{ 165| 96.0k| free (hash_table->entries); 166| 96.0k|} _csi_hash_table_lookup: 305| 19.4M|{ 306| 19.4M| csi_hash_entry_t **entry; 307| 19.4M| unsigned long table_size, i, idx, step; 308| | 309| 19.4M| table_size = hash_table->arrangement->size; 310| 19.4M| idx = key->hash % table_size; 311| 19.4M| entry = &hash_table->entries[idx]; 312| | 313| 19.4M| if (ENTRY_IS_LIVE (*entry)) { ------------------ | | 63| 19.4M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 19.4M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ | | | Branch (63:30): [True: 9.44M, False: 10.0M] | | ------------------ ------------------ 314| 9.44M| if ((*entry)->hash == key->hash && hash_table->keys_equal (key, *entry)) ------------------ | Branch (314:6): [True: 6.94M, False: 2.49M] | Branch (314:37): [True: 6.94M, False: 1.48k] ------------------ 315| 6.94M| return *entry; 316| 10.0M| } else if (ENTRY_IS_FREE (*entry)) ------------------ | | 61| 10.0M|#define ENTRY_IS_FREE(entry) ((entry) == NULL) | | ------------------ | | | Branch (61:30): [True: 10.0M, False: 0] | | ------------------ ------------------ 317| 10.0M| return NULL; 318| | 319| 2.49M| i = 1; 320| 2.49M| step = key->hash % hash_table->arrangement->rehash; 321| 2.49M| if (step == 0) ------------------ | Branch (321:9): [True: 2.48k, False: 2.49M] ------------------ 322| 2.48k| step = 1; 323| 3.10M| do { 324| 3.10M| idx += step; 325| 3.10M| if (idx >= table_size) ------------------ | Branch (325:6): [True: 897k, False: 2.20M] ------------------ 326| 897k| idx -= table_size; 327| | 328| 3.10M| entry = &hash_table->entries[idx]; 329| 3.10M| if (ENTRY_IS_LIVE (*entry)) { ------------------ | | 63| 3.10M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 3.10M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ | | | Branch (63:30): [True: 1.76M, False: 1.34M] | | ------------------ ------------------ 330| 1.76M| if ((*entry)->hash == key->hash && ------------------ | Branch (330:10): [True: 1.15M, False: 606k] ------------------ 331| 1.15M| hash_table->keys_equal (key, *entry)) ------------------ | Branch (331:3): [True: 1.15M, False: 267] ------------------ 332| 1.15M| { 333| 1.15M| return *entry; 334| 1.15M| } 335| 1.76M| } else if (ENTRY_IS_FREE (*entry)) ------------------ | | 61| 1.34M|#define ENTRY_IS_FREE(entry) ((entry) == NULL) | | ------------------ | | | Branch (61:30): [True: 1.34M, False: 0] | | ------------------ ------------------ 336| 1.34M| return NULL; 337| 3.10M| } while (++i < table_size); ------------------ | Branch (337:14): [True: 606k, False: 0] ------------------ 338| | 339| 0| return NULL; 340| 2.49M|} _csi_hash_table_insert: 365| 3.66M|{ 366| 3.66M| csi_status_t status; 367| 3.66M| csi_hash_entry_t **entry; 368| | 369| 3.66M| hash_table->live_entries++; 370| 3.66M| status = _csi_hash_table_manage (hash_table); 371| 3.66M| if (_csi_unlikely (status)) { ------------------ | | 120| 3.66M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.66M| __extension__ ({ \ | | | | 112| 3.66M| int _csi_boolean_var_; \ | | | | 113| 3.66M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.66M] | | | | ------------------ | | | | 114| 3.66M| _csi_boolean_var_ = 1; \ | | | | 115| 3.66M| else \ | | | | 116| 3.66M| _csi_boolean_var_ = 0; \ | | | | 117| 3.66M| _csi_boolean_var_; \ | | | | 118| 3.66M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 3.66M] | | ------------------ ------------------ 372| | /* abort the insert... */ 373| 0| hash_table->live_entries--; 374| 0| return status; 375| 0| } 376| | 377| 3.66M| entry = _csi_hash_table_lookup_unique_key (hash_table, 378| 3.66M| key_and_value); 379| 3.66M| if (ENTRY_IS_FREE (*entry)) ------------------ | | 61| 3.66M|#define ENTRY_IS_FREE(entry) ((entry) == NULL) | | ------------------ | | | Branch (61:30): [True: 3.66M, False: 0] | | ------------------ ------------------ 380| 3.66M| hash_table->used_entries++; 381| | 382| 3.66M| *entry = key_and_value; 383| 3.66M| return CAIRO_STATUS_SUCCESS; 384| 3.66M|} _csi_hash_table_remove: 429| 2.18M|{ 430| 2.18M| *_csi_hash_table_lookup_exact_key (hash_table, key) = DEAD_ENTRY; ------------------ | | 59| 2.18M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) ------------------ 431| 2.18M| hash_table->live_entries--; 432| | 433| | /* Check for table resize. Don't do this when iterating as this will 434| | * reorder elements of the table and cause the iteration to potentially 435| | * skip some elements. */ 436| 2.18M| if (hash_table->iterating == 0) { ------------------ | Branch (436:9): [True: 0, False: 2.18M] ------------------ 437| | /* This call _can_ fail, but only in failing to allocate new 438| | * memory to shrink the hash table. It does leave the table in a 439| | * consistent state, and we've already succeeded in removing the 440| | * entry, so we don't examine the failure status of this call. */ 441| 0| _csi_hash_table_manage (hash_table); 442| 0| } 443| 2.18M|} _csi_hash_table_foreach: 464| 101k|{ 465| 101k| unsigned long i; 466| 101k| csi_hash_entry_t *entry; 467| | 468| | /* Mark the table for iteration */ 469| 101k| ++hash_table->iterating; 470| 16.7M| for (i = 0; i < hash_table->arrangement->size; i++) { ------------------ | Branch (470:17): [True: 16.6M, False: 101k] ------------------ 471| 16.6M| entry = hash_table->entries[i]; 472| 16.6M| if (ENTRY_IS_LIVE(entry)) ------------------ | | 63| 16.6M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 16.6M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ | | | Branch (63:30): [True: 2.18M, False: 14.4M] | | ------------------ ------------------ 473| 2.18M| hash_callback (entry, closure); 474| 16.6M| } 475| | /* If some elements were deleted during the iteration, 476| | * the table may need resizing. Just do this every time 477| | * as the check is inexpensive. 478| | */ 479| 101k| if (--hash_table->iterating == 0) { ------------------ | Branch (479:9): [True: 101k, False: 0] ------------------ 480| | /* Should we fail to shrink the hash table, it is left unaltered, 481| | * and we don't need to propagate the error status. */ 482| 101k| _csi_hash_table_manage (hash_table); 483| 101k| } 484| 101k|} cairo-script-hash.c:_csi_hash_table_manage: 213| 3.76M|{ 214| 3.76M| csi_hash_table_t tmp; 215| 3.76M| csi_boolean_t realloc = TRUE; ------------------ | | 55| 3.76M|#define TRUE (!FALSE) | | ------------------ | | | | 51| 3.76M|#define FALSE 0 | | ------------------ ------------------ 216| 3.76M| unsigned long i; 217| | 218| | /* This keeps the size of the hash table between 2 and approximately 8 219| | * times the number of live entries and keeps the proportion of free 220| | * entries (search-terminations) > 25%. 221| | */ 222| 3.76M| unsigned long high = hash_table->arrangement->high_water_mark; 223| 3.76M| unsigned long low = high >> 2; 224| 3.76M| unsigned long max_used = high + high / 2; 225| | 226| 3.76M| tmp = *hash_table; 227| | 228| 3.76M| if (hash_table->live_entries > high) { ------------------ | Branch (228:9): [True: 72.0k, False: 3.69M] ------------------ 229| 72.0k| tmp.arrangement = hash_table->arrangement + 1; 230| | /* This code is being abused if we can't make a table big enough. */ 231| 3.69M| } else if (hash_table->live_entries < low && ------------------ | Branch (231:16): [True: 148k, False: 3.54M] ------------------ 232| | /* Can't shrink if we're at the smallest size */ 233| 148k| hash_table->arrangement != &hash_table_arrangements[0]) ------------------ | Branch (233:9): [True: 20.4k, False: 127k] ------------------ 234| 20.4k| { 235| 20.4k| tmp.arrangement = hash_table->arrangement - 1; 236| 20.4k| } 237| 3.67M| else if (hash_table->used_entries > max_used) ------------------ | Branch (237:14): [True: 0, False: 3.67M] ------------------ 238| 0| { 239| | /* Clean out dead entries to prevent lookups from becoming too slow. */ 240| 0| for (i = 0; i < hash_table->arrangement->size; ++i) { ------------------ | Branch (240:14): [True: 0, False: 0] ------------------ 241| 0| if (ENTRY_IS_DEAD (hash_table->entries[i])) ------------------ | | 62| 0|#define ENTRY_IS_DEAD(entry) ((entry) == DEAD_ENTRY) | | ------------------ | | | | 59| 0|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ | | | Branch (62:30): [True: 0, False: 0] | | ------------------ ------------------ 242| 0| hash_table->entries[i] = NULL; 243| 0| } 244| 0| hash_table->used_entries = hash_table->live_entries; 245| | 246| | /* There is no need to reallocate but some entries may need to be 247| | * moved. Typically the proportion of entries needing to be moved is 248| | * small, but, if the moving should leave a large number of dead 249| | * entries, they will be cleaned out next time this code is 250| | * executed. */ 251| 0| realloc = FALSE; ------------------ | | 51| 0|#define FALSE 0 ------------------ 252| 0| } 253| 3.67M| else 254| 3.67M| { 255| 3.67M| return CAIRO_STATUS_SUCCESS; 256| 3.67M| } 257| | 258| 92.4k| if (realloc) { ------------------ | Branch (258:9): [True: 92.4k, False: 0] ------------------ 259| 92.4k| tmp.entries = calloc (tmp.arrangement->size, 260| 92.4k| sizeof (csi_hash_entry_t*)); 261| 92.4k| if (tmp.entries == NULL) ------------------ | Branch (261:6): [True: 0, False: 92.4k] ------------------ 262| 0| return _csi_error (CAIRO_STATUS_NO_MEMORY); 263| | 264| 92.4k| hash_table->used_entries = 0; 265| 92.4k| } 266| | 267| 27.6M| for (i = 0; i < hash_table->arrangement->size; ++i) { ------------------ | Branch (267:17): [True: 27.5M, False: 92.4k] ------------------ 268| 27.5M| csi_hash_entry_t *entry, **pos; 269| | 270| 27.5M| entry = hash_table->entries[i]; 271| 27.5M| if (ENTRY_IS_LIVE (entry)) { ------------------ | | 63| 27.5M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 27.5M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ | | | Branch (63:30): [True: 6.34M, False: 21.2M] | | ------------------ ------------------ 272| 6.34M| hash_table->entries[i] = DEAD_ENTRY; ------------------ | | 59| 6.34M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) ------------------ 273| | 274| 6.34M| pos = _csi_hash_table_lookup_unique_key (&tmp, entry); 275| 6.34M| if (ENTRY_IS_FREE (*pos)) ------------------ | | 61| 6.34M|#define ENTRY_IS_FREE(entry) ((entry) == NULL) | | ------------------ | | | Branch (61:30): [True: 6.34M, False: 0] | | ------------------ ------------------ 276| 6.34M| hash_table->used_entries++; 277| | 278| 6.34M| *pos = entry; 279| 6.34M| } 280| 27.5M| } 281| | 282| 92.4k| if (realloc) { ------------------ | Branch (282:9): [True: 92.4k, False: 0] ------------------ 283| 92.4k| free (hash_table->entries); 284| 92.4k| hash_table->entries = tmp.entries; 285| 92.4k| hash_table->arrangement = tmp.arrangement; 286| 92.4k| } 287| | 288| 92.4k| return CAIRO_STATUS_SUCCESS; 289| 92.4k|} cairo-script-hash.c:_csi_hash_table_lookup_unique_key: 171| 10.0M|{ 172| 10.0M| unsigned long table_size, i, idx, step; 173| 10.0M| csi_hash_entry_t **entry; 174| | 175| 10.0M| table_size = hash_table->arrangement->size; 176| 10.0M| idx = key->hash % table_size; 177| | 178| 10.0M| entry = &hash_table->entries[idx]; 179| 10.0M| if (! ENTRY_IS_LIVE (*entry)) ------------------ | | 63| 10.0M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 10.0M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ ------------------ | Branch (179:9): [True: 8.53M, False: 1.46M] ------------------ 180| 8.53M| return entry; 181| | 182| 1.46M| i = 1; 183| 1.46M| step = key->hash % hash_table->arrangement->rehash; 184| 1.46M| if (step == 0) ------------------ | Branch (184:9): [True: 2.41k, False: 1.46M] ------------------ 185| 2.41k| step = 1; 186| 2.02M| do { 187| 2.02M| idx += step; 188| 2.02M| if (idx >= table_size) ------------------ | Branch (188:6): [True: 938k, False: 1.08M] ------------------ 189| 938k| idx -= table_size; 190| | 191| 2.02M| entry = &hash_table->entries[idx]; 192| 2.02M| if (! ENTRY_IS_LIVE (*entry)) ------------------ | | 63| 2.02M|#define ENTRY_IS_LIVE(entry) ((entry) > DEAD_ENTRY) | | ------------------ | | | | 59| 2.02M|#define DEAD_ENTRY ((csi_hash_entry_t *) 0x1) | | ------------------ ------------------ | Branch (192:6): [True: 1.46M, False: 558k] ------------------ 193| 1.46M| return entry; 194| 2.02M| } while (++i < table_size); ------------------ | Branch (194:14): [True: 558k, False: 0] ------------------ 195| | 196| 0| return NULL; 197| 1.46M|} cairo-script-hash.c:_csi_hash_table_lookup_exact_key: 389| 2.18M|{ 390| 2.18M| unsigned long table_size, i, idx, step; 391| 2.18M| csi_hash_entry_t **entry; 392| | 393| 2.18M| table_size = hash_table->arrangement->size; 394| 2.18M| idx = key->hash % table_size; 395| | 396| 2.18M| entry = &hash_table->entries[idx]; 397| 2.18M| if (*entry == key) ------------------ | Branch (397:9): [True: 2.09M, False: 97.8k] ------------------ 398| 2.09M| return entry; 399| | 400| 97.8k| i = 1; 401| 97.8k| step = key->hash % hash_table->arrangement->rehash; 402| 97.8k| if (step == 0) ------------------ | Branch (402:9): [True: 1, False: 97.8k] ------------------ 403| 1| step = 1; 404| 112k| do { 405| 112k| idx += step; 406| 112k| if (idx >= table_size) ------------------ | Branch (406:6): [True: 52.9k, False: 59.4k] ------------------ 407| 52.9k| idx -= table_size; 408| | 409| 112k| entry = &hash_table->entries[idx]; 410| 112k| if (*entry == key) ------------------ | Branch (410:6): [True: 97.8k, False: 14.4k] ------------------ 411| 97.8k| return entry; 412| 112k| } while (++i < table_size); ------------------ | Branch (412:14): [True: 14.4k, False: 0] ------------------ 413| | 414| 0| return NULL; 415| 97.8k|} _csi_error: 53| 3.15k|{ 54| 3.15k| return status; 55| 3.15k|} _csi_alloc: 60| 1.51M|{ 61| 1.51M| return malloc (size); 62| 1.51M|} _csi_realloc: 78| 3.99k|{ 79| 3.99k| return realloc (ptr, size); 80| 3.99k|} _csi_free: 84| 1.48M|{ 85| 1.48M| if (_csi_unlikely (ptr == NULL)) ------------------ | | 120| 1.48M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.48M| __extension__ ({ \ | | | | 112| 1.48M| int _csi_boolean_var_; \ | | | | 113| 1.48M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 1.48M] | | | | ------------------ | | | | 114| 1.48M| _csi_boolean_var_ = 1; \ | | | | 115| 1.48M| else \ | | | | 116| 1.48M| _csi_boolean_var_ = 0; \ | | | | 117| 1.48M| _csi_boolean_var_; \ | | | | 118| 1.48M|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 1.48M] | | ------------------ ------------------ 86| 1| return; 87| | 88| 1.48M| free (ptr); 89| 1.48M|} _csi_perm_alloc: 93| 1.47M|{ 94| 1.47M| csi_chunk_t *chunk; 95| 1.47M| void *ptr; 96| | 97| 1.47M| size = (size + sizeof (void *)-1) & -sizeof (void *); 98| | 99| 1.47M| chunk = ctx->perm_chunk; 100| 1.47M| if (chunk == NULL || chunk->rem < size) { ------------------ | Branch (100:9): [True: 5.14k, False: 1.46M] | Branch (100:26): [True: 5.22k, False: 1.46M] ------------------ 101| 10.3k| int chunk_size = (size + 8191) & -8192; 102| 10.3k| chunk = _csi_alloc (ctx, sizeof (csi_chunk_t) + chunk_size); 103| 10.3k| if (_csi_unlikely (chunk == NULL)) ------------------ | | 120| 10.3k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.3k| __extension__ ({ \ | | | | 112| 10.3k| int _csi_boolean_var_; \ | | | | 113| 10.3k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 10.3k] | | | | ------------------ | | | | 114| 10.3k| _csi_boolean_var_ = 1; \ | | | | 115| 10.3k| else \ | | | | 116| 10.3k| _csi_boolean_var_ = 0; \ | | | | 117| 10.3k| _csi_boolean_var_; \ | | | | 118| 10.3k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 10.3k] | | ------------------ ------------------ 104| 0| return NULL; 105| | 106| 10.3k| chunk->rem = chunk_size; 107| 10.3k| chunk->ptr = (char *) (chunk + 1); 108| 10.3k| chunk->next = ctx->perm_chunk; 109| 10.3k| ctx->perm_chunk = chunk; 110| 10.3k| } 111| | 112| 1.47M| ptr = chunk->ptr; 113| 1.47M| chunk->ptr += size; 114| 1.47M| chunk->rem -= size; 115| | 116| 1.47M| return ptr; 117| 1.47M|} _csi_slab_alloc: 121| 3.74M|{ 122| |#if CSI_DEBUG_MALLOC 123| | return malloc (size); 124| |#else 125| 3.74M| int chunk_size; 126| 3.74M| csi_chunk_t *chunk; 127| 3.74M| void *ptr; 128| | 129| 3.74M| chunk_size = 2 * sizeof (void *); 130| 3.74M| chunk_size = (size + chunk_size - 1) / chunk_size; 131| | 132| 3.74M| if (ctx->slabs[chunk_size].free_list) { ------------------ | Branch (132:9): [True: 488k, False: 3.25M] ------------------ 133| 488k| ptr = ctx->slabs[chunk_size].free_list; 134| 488k| ctx->slabs[chunk_size].free_list = *(void **) ptr; 135| 488k| return ptr; 136| 488k| } 137| | 138| 3.25M| chunk = ctx->slabs[chunk_size].chunk; 139| 3.25M| if (chunk == NULL || ! chunk->rem) { ------------------ | Branch (139:9): [True: 10.9k, False: 3.24M] | Branch (139:26): [True: 11.5k, False: 3.23M] ------------------ 140| 22.5k| int cnt = MAX (128, 8192 / (chunk_size * 2 * sizeof (void *))); ------------------ | | 48| 22.5k|#define MAX(a,b) (((a)>=(b))?(a):(b)) | | ------------------ | | | Branch (48:19): [True: 5.69k, False: 16.8k] | | ------------------ ------------------ 141| | 142| 22.5k| chunk = _csi_alloc (ctx, 143| 22.5k| sizeof (csi_chunk_t) + 144| 22.5k| cnt * chunk_size * 2 * sizeof (void *)); 145| 22.5k| if (_csi_unlikely (chunk == NULL)) ------------------ | | 120| 22.5k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 22.5k| __extension__ ({ \ | | | | 112| 22.5k| int _csi_boolean_var_; \ | | | | 113| 22.5k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 22.5k] | | | | ------------------ | | | | 114| 22.5k| _csi_boolean_var_ = 1; \ | | | | 115| 22.5k| else \ | | | | 116| 22.5k| _csi_boolean_var_ = 0; \ | | | | 117| 22.5k| _csi_boolean_var_; \ | | | | 118| 22.5k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 22.5k] | | ------------------ ------------------ 146| 0| return NULL; 147| | 148| 22.5k| chunk->rem = cnt; 149| 22.5k| chunk->ptr = (char *) (chunk + 1); 150| 22.5k| chunk->next = ctx->slabs[chunk_size].chunk; 151| 22.5k| ctx->slabs[chunk_size].chunk = chunk; 152| 22.5k| } 153| | 154| 3.25M| ptr = chunk->ptr; 155| 3.25M| chunk->ptr += chunk_size * 2 * sizeof (void *); 156| 3.25M| chunk->rem--; 157| | 158| 3.25M| return ptr; 159| 3.25M|#endif 160| 3.25M|} _csi_slab_free: 164| 3.71M|{ 165| 3.71M| int chunk_size; 166| 3.71M| void **free_list; 167| | 168| 3.71M| if (_csi_unlikely (ptr == NULL)) ------------------ | | 120| 3.71M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.71M| __extension__ ({ \ | | | | 112| 3.71M| int _csi_boolean_var_; \ | | | | 113| 3.71M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.71M] | | | | ------------------ | | | | 114| 3.71M| _csi_boolean_var_ = 1; \ | | | | 115| 3.71M| else \ | | | | 116| 3.71M| _csi_boolean_var_ = 0; \ | | | | 117| 3.71M| _csi_boolean_var_; \ | | | | 118| 3.71M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 3.71M] | | ------------------ ------------------ 169| 0| return; 170| | 171| |#if CSI_DEBUG_MALLOC 172| | free (ptr); 173| |#else 174| 3.71M| chunk_size = 2 * sizeof (void *); 175| 3.71M| chunk_size = (size + chunk_size - 1) / chunk_size; 176| | 177| 3.71M| free_list = ptr; 178| 3.71M| *free_list = ctx->slabs[chunk_size].free_list; 179| 3.71M| ctx->slabs[chunk_size].free_list = ptr; 180| 3.71M|#endif 181| 3.71M|} _csi_stack_push: 186| 6.88M|{ 187| 6.88M| if (_csi_unlikely (stack->len == stack->size)) ------------------ | | 120| 6.88M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6.88M| __extension__ ({ \ | | | | 112| 6.88M| int _csi_boolean_var_; \ | | | | 113| 6.88M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3.62k, False: 6.87M] | | | | ------------------ | | | | 114| 6.88M| _csi_boolean_var_ = 1; \ | | | | 115| 6.88M| else \ | | | | 116| 6.88M| _csi_boolean_var_ = 0; \ | | | | 117| 6.88M| _csi_boolean_var_; \ | | | | 118| 6.88M|}) | | ------------------ | | | Branch (120:29): [True: 3.62k, False: 6.87M] | | ------------------ ------------------ 188| 3.62k| return _csi_stack_push_internal (ctx, stack, obj); 189| | 190| 6.87M| stack->objects[stack->len++] = *obj; 191| 6.87M| return CSI_STATUS_SUCCESS; 192| 6.88M|} _csi_name_define: 448| 55|{ 449| 55| return csi_dictionary_put (ctx, 450| 55| ctx->dstack.objects[ctx->dstack.len-1].datum.dictionary, 451| 55| name, 452| 55| obj); 453| 55|} _csi_name_lookup: 457| 3.49M|{ 458| 3.49M| int i; 459| | 460| 10.4M| for (i = ctx->dstack.len; i--; ) { ------------------ | Branch (460:31): [True: 10.4M, False: 789] ------------------ 461| 10.4M| csi_dictionary_t *dict; 462| 10.4M| csi_dictionary_entry_t *entry; 463| | 464| 10.4M| dict = ctx->dstack.objects[i].datum.dictionary; 465| 10.4M| entry = _csi_hash_table_lookup (&dict->hash_table, 466| 10.4M| (csi_hash_entry_t *) &name); 467| 10.4M| if (entry != NULL) { ------------------ | Branch (467:6): [True: 3.49M, False: 6.99M] ------------------ 468| 3.49M| *obj = entry->value; 469| 3.49M| return CSI_STATUS_SUCCESS; 470| 3.49M| } 471| 10.4M| } 472| | 473| 789| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 474| 3.49M|} _csi_name_undefine: 478| 1|{ 479| 1| unsigned int i; 480| | 481| 3| for (i = ctx->dstack.len; --i; ) { ------------------ | Branch (481:31): [True: 2, False: 1] ------------------ 482| 2| if (csi_dictionary_has (ctx->dstack.objects[i].datum.dictionary, ------------------ | Branch (482:6): [True: 0, False: 2] ------------------ 483| 2| name)) 484| 0| { 485| 0| csi_dictionary_remove (ctx, 486| 0| ctx->dstack.objects[i].datum.dictionary, 487| 0| name); 488| 0| return CSI_STATUS_SUCCESS; 489| 0| } 490| 2| } 491| | 492| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 493| 1|} _csi_intern_string: 497| 5.78M|{ 498| 5.78M| char *str = (char *) *str_inout; 499| 5.78M| csi_intern_string_t tmpl, *istring; 500| 5.78M| csi_status_t status = CSI_STATUS_SUCCESS; 501| | 502| 5.78M| tmpl.hash_entry.hash = _intern_string_hash (str, len); 503| 5.78M| tmpl.len = len; 504| 5.78M| tmpl.string = (char *) str; 505| | 506| 5.78M| istring = _csi_hash_table_lookup (&ctx->strings, &tmpl.hash_entry); 507| 5.78M| if (istring == NULL) { ------------------ | Branch (507:9): [True: 1.47M, False: 4.31M] ------------------ 508| 1.47M| istring = _csi_perm_alloc (ctx, 509| 1.47M| sizeof (csi_intern_string_t) + len + 1); 510| 1.47M| if (istring != NULL) { ------------------ | Branch (510:6): [True: 1.47M, False: 0] ------------------ 511| 1.47M| istring->hash_entry.hash = tmpl.hash_entry.hash; 512| 1.47M| istring->len = tmpl.len; 513| 1.47M| istring->string = (char *) (istring + 1); 514| 1.47M| memcpy (istring->string, str, len); 515| 1.47M| istring->string[len] = '\0'; 516| | 517| 1.47M| status = _csi_hash_table_insert (&ctx->strings, 518| 1.47M| &istring->hash_entry); 519| 1.47M| if (_csi_unlikely (status)) { ------------------ | | 120| 1.47M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.47M| __extension__ ({ \ | | | | 112| 1.47M| int _csi_boolean_var_; \ | | | | 113| 1.47M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.47M] | | | | ------------------ | | | | 114| 1.47M| _csi_boolean_var_ = 1; \ | | | | 115| 1.47M| else \ | | | | 116| 1.47M| _csi_boolean_var_ = 0; \ | | | | 117| 1.47M| _csi_boolean_var_; \ | | | | 118| 1.47M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.47M] | | ------------------ ------------------ 520| 0| _csi_free (ctx, istring); 521| 0| return status; 522| 0| } 523| 1.47M| } else 524| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 525| 1.47M| } 526| | 527| 5.78M| *str_inout = istring->string; 528| 5.78M| return CSI_STATUS_SUCCESS; 529| 5.78M|} cairo_script_interpreter_create: 537| 5.14k|{ 538| 5.14k| csi_t *ctx; 539| | 540| 5.14k| ctx = malloc (sizeof (csi_t)); 541| 5.14k| if (ctx == NULL) ------------------ | Branch (541:9): [True: 0, False: 5.14k] ------------------ 542| 0| return (csi_t *) &_csi_nil; 543| | 544| 5.14k| _csi_init (ctx); 545| | 546| 5.14k| return ctx; 547| 5.14k|} cairo_script_interpreter_install_hooks: 552| 5.14k|{ 553| 5.14k| if (ctx->status) ------------------ | Branch (553:9): [True: 0, False: 5.14k] ------------------ 554| 0| return; 555| | 556| 5.14k| ctx->hooks = *hooks; 557| 5.14k|} cairo_script_interpreter_feed_string: 605| 5.14k|{ 606| 5.14k| csi_object_t file; 607| | 608| 5.14k| if (ctx->status) ------------------ | Branch (608:9): [True: 0, False: 5.14k] ------------------ 609| 0| return ctx->status; 610| 5.14k| if (ctx->finished) ------------------ | Branch (610:9): [True: 0, False: 5.14k] ------------------ 611| 0| return ctx->status = CSI_STATUS_INTERPRETER_FINISHED; 612| | 613| 5.14k| if (len < 0) ------------------ | Branch (613:9): [True: 0, False: 5.14k] ------------------ 614| 0| len = strlen (line); 615| 5.14k| ctx->status = csi_file_new_for_bytes (ctx, &file, line, len); 616| 5.14k| if (ctx->status) ------------------ | Branch (616:9): [True: 0, False: 5.14k] ------------------ 617| 0| return ctx->status; 618| | 619| 5.14k| file.type |= CSI_OBJECT_ATTR_EXECUTABLE; 620| | 621| 5.14k| ctx->status = csi_object_execute (ctx, &file); 622| 5.14k| csi_object_free (ctx, &file); 623| | 624| 5.14k| return ctx->status; 625| 5.14k|} cairo_script_interpreter_finish: 642| 5.14k|{ 643| 5.14k| csi_status_t status; 644| | 645| 5.14k| status = ctx->status; 646| 5.14k| if (! ctx->finished) { ------------------ | Branch (646:9): [True: 5.14k, False: 0] ------------------ 647| 5.14k| _csi_finish (ctx); 648| 5.14k| ctx->finished = 1; 649| 5.14k| } else if (status == CSI_STATUS_SUCCESS) { ------------------ | Branch (649:16): [True: 0, False: 0] ------------------ 650| 0| status = ctx->status = CSI_STATUS_INTERPRETER_FINISHED; 651| 0| } 652| | 653| 5.14k| return status; 654| 5.14k|} cairo_script_interpreter_destroy: 675| 5.14k|{ 676| 5.14k| csi_status_t status; 677| | 678| 5.14k| status = ctx->status; 679| 5.14k| if (--ctx->ref_count) ------------------ | Branch (679:9): [True: 0, False: 5.14k] ------------------ 680| 0| return status; 681| | 682| 5.14k| _csi_fini (ctx); 683| 5.14k| free (ctx); 684| | 685| 5.14k| return status; 686| 5.14k|} cairo-script-interpreter.c:_intern_string_hash: 378| 5.78M|{ 379| 5.78M| const signed char *p = (const signed char *) str; 380| 5.78M| if (len > 0) { ------------------ | Branch (380:9): [True: 5.78M, False: 1.01k] ------------------ 381| 5.78M| unsigned int h = *p; 382| | 383| 30.2M| while (--len) ------------------ | Branch (383:9): [True: 24.4M, False: 5.78M] ------------------ 384| 24.4M| h = (h << 5) - h + *++p; 385| | 386| 5.78M| return h; 387| 5.78M| } 388| 1.01k| return 0; 389| 5.78M|} cairo-script-interpreter.c:_csi_init: 405| 5.14k|{ 406| 5.14k| csi_status_t status; 407| | 408| 5.14k| memset (ctx, 0, sizeof (*ctx)); 409| | 410| 5.14k| ctx->status = CSI_STATUS_SUCCESS; 411| 5.14k| ctx->ref_count = 1; 412| 5.14k| ctx->scanner.line_number = -1; 413| | 414| 5.14k| status = _csi_hash_table_init (&ctx->strings, _intern_string_equal); 415| 5.14k| if (status) ------------------ | Branch (415:9): [True: 0, False: 5.14k] ------------------ 416| 0| goto FAIL; 417| | 418| 5.14k| status = _csi_stack_init (ctx, &ctx->ostack, 2048); 419| 5.14k| if (status) ------------------ | Branch (419:9): [True: 0, False: 5.14k] ------------------ 420| 0| goto FAIL; 421| 5.14k| status = _init_dictionaries (ctx); 422| 5.14k| if (status) ------------------ | Branch (422:9): [True: 0, False: 5.14k] ------------------ 423| 0| goto FAIL; 424| | 425| 5.14k| status = _csi_scanner_init (ctx, &ctx->scanner); 426| 5.14k| if (status) ------------------ | Branch (426:9): [True: 0, False: 5.14k] ------------------ 427| 0| goto FAIL; 428| | 429| 5.14k| return; 430| | 431| 5.14k|FAIL: 432| 0| if (ctx->status == CSI_STATUS_SUCCESS) ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| ctx->status = status; 434| 0|} cairo-script-interpreter.c:_intern_string_equal: 393| 4.31M|{ 394| 4.31M| const csi_intern_string_t *a = _a; 395| 4.31M| const csi_intern_string_t *b = _b; 396| | 397| 4.31M| if (a->len != b->len) ------------------ | Branch (397:9): [True: 543, False: 4.31M] ------------------ 398| 543| return FALSE; ------------------ | | 51| 543|#define FALSE 0 ------------------ 399| | 400| 4.31M| return memcmp (a->string, b->string, a->len) == 0; 401| 4.31M|} cairo-script-interpreter.c:_init_dictionaries: 274| 5.14k|{ 275| 5.14k| csi_status_t status; 276| 5.14k| csi_stack_t *stack; 277| 5.14k| csi_object_t obj; 278| 5.14k| csi_dictionary_t *dict, *opcodes; 279| 5.14k| const csi_operator_def_t *odef; 280| 5.14k| const csi_integer_constant_def_t *idef; 281| 5.14k| const csi_real_constant_def_t *rdef; 282| 5.14k| unsigned n; 283| | 284| 5.14k| stack = &ctx->dstack; 285| | 286| 5.14k| status = _csi_stack_init (ctx, stack, 4); 287| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 288| 0| return status; 289| | 290| | /* systemdict */ 291| 5.14k| status = csi_dictionary_new (ctx, &obj); 292| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 293| 0| return status; 294| | 295| 5.14k| status = _csi_stack_push (ctx, stack, &obj); 296| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 297| 0| return status; 298| | 299| 5.14k| dict = obj.datum.dictionary; 300| | 301| 5.14k| status = csi_dictionary_new (ctx, &obj); 302| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 303| 0| return status; 304| | 305| 5.14k| opcodes = obj.datum.dictionary; 306| | 307| 5.14k| n = 0; 308| 5.14k| csi_integer_new (&obj, n); 309| 5.14k| status = csi_dictionary_put (ctx, opcodes, 0, &obj); 310| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 311| 0| return status; 312| 5.14k| ctx->opcode[n++] = NULL; 313| | 314| | /* fill systemdict with operators */ 315| 1.00M| for (odef = _csi_operators (); odef->name != NULL; odef++) { ------------------ | Branch (315:36): [True: 1.00M, False: 5.14k] ------------------ 316| 1.00M| status = _add_operator (ctx, dict, odef); 317| 1.00M| if (_csi_unlikely (status)) ------------------ | | 120| 1.00M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.00M| __extension__ ({ \ | | | | 112| 1.00M| int _csi_boolean_var_; \ | | | | 113| 1.00M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.00M] | | | | ------------------ | | | | 114| 1.00M| _csi_boolean_var_ = 1; \ | | | | 115| 1.00M| else \ | | | | 116| 1.00M| _csi_boolean_var_ = 0; \ | | | | 117| 1.00M| _csi_boolean_var_; \ | | | | 118| 1.00M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.00M] | | ------------------ ------------------ 318| 0| return status; 319| | 320| 1.00M| if (! csi_dictionary_has (opcodes, (csi_name_t) odef->op)) { ------------------ | Branch (320:6): [True: 715k, False: 288k] ------------------ 321| 715k| csi_integer_new (&obj, n); 322| 715k| status = csi_dictionary_put (ctx, 323| 715k| opcodes, (csi_name_t) odef->op, &obj); 324| 715k| if (_csi_unlikely (status)) ------------------ | | 120| 715k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 715k| __extension__ ({ \ | | | | 112| 715k| int _csi_boolean_var_; \ | | | | 113| 715k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 715k] | | | | ------------------ | | | | 114| 715k| _csi_boolean_var_ = 1; \ | | | | 115| 715k| else \ | | | | 116| 715k| _csi_boolean_var_ = 0; \ | | | | 117| 715k| _csi_boolean_var_; \ | | | | 118| 715k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 715k] | | ------------------ ------------------ 325| 0| return status; 326| | 327| 715k| assert (n < sizeof (ctx->opcode) / sizeof (ctx->opcode[0])); ------------------ | Branch (327:6): [True: 0, False: 715k] | Branch (327:6): [True: 715k, False: 0] ------------------ 328| 715k| ctx->opcode[n++] = odef->op; 329| 715k| } 330| 1.00M| } 331| 5.14k| csi_dictionary_free (ctx, opcodes); 332| | 333| | /* add constants */ 334| 447k| for (idef = _csi_integer_constants (); idef->name != NULL; idef++) { ------------------ | Branch (334:44): [True: 442k, False: 5.14k] ------------------ 335| 442k| status = _add_integer_constant (ctx, dict, idef); 336| 442k| if (_csi_unlikely (status)) ------------------ | | 120| 442k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 442k| __extension__ ({ \ | | | | 112| 442k| int _csi_boolean_var_; \ | | | | 113| 442k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 442k] | | | | ------------------ | | | | 114| 442k| _csi_boolean_var_ = 1; \ | | | | 115| 442k| else \ | | | | 116| 442k| _csi_boolean_var_ = 0; \ | | | | 117| 442k| _csi_boolean_var_; \ | | | | 118| 442k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 442k] | | ------------------ ------------------ 337| 0| return status; 338| 442k| } 339| 25.7k| for (rdef = _csi_real_constants (); rdef->name != NULL; rdef++) { ------------------ | Branch (339:41): [True: 20.5k, False: 5.14k] ------------------ 340| 20.5k| status = _add_real_constant (ctx, dict, rdef); 341| 20.5k| if (_csi_unlikely (status)) ------------------ | | 120| 20.5k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 20.5k| __extension__ ({ \ | | | | 112| 20.5k| int _csi_boolean_var_; \ | | | | 113| 20.5k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 20.5k] | | | | ------------------ | | | | 114| 20.5k| _csi_boolean_var_ = 1; \ | | | | 115| 20.5k| else \ | | | | 116| 20.5k| _csi_boolean_var_ = 0; \ | | | | 117| 20.5k| _csi_boolean_var_; \ | | | | 118| 20.5k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 20.5k] | | ------------------ ------------------ 342| 0| return status; 343| 20.5k| } 344| | 345| | /* and seal */ 346| | //dict.type &= ~CSI_OBJECT_ATTR_WRITABLE; 347| | 348| | 349| | /* globaldict */ 350| 5.14k| status = csi_dictionary_new (ctx, &obj); 351| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 352| 0| return status; 353| 5.14k| status = _csi_stack_push (ctx, stack, &obj); 354| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 355| 0| return status; 356| | 357| | /* userdict */ 358| 5.14k| status = csi_dictionary_new (ctx, &obj); 359| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 360| 0| return status; 361| 5.14k| status = _csi_stack_push (ctx, stack, &obj); 362| 5.14k| if (_csi_unlikely (status)) ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 363| 0| return status; 364| | 365| 5.14k| return CSI_STATUS_SUCCESS; 366| 5.14k|} cairo-script-interpreter.c:_add_operator: 222| 1.00M|{ 223| 1.00M| csi_object_t name; 224| 1.00M| csi_object_t operator; 225| 1.00M| csi_status_t status; 226| | 227| 1.00M| status = csi_name_new_static (ctx, &name, def->name); 228| 1.00M| if (status) ------------------ | Branch (228:9): [True: 0, False: 1.00M] ------------------ 229| 0| return status; 230| | 231| 1.00M| csi_operator_new (&operator, def->op); 232| | 233| 1.00M| return csi_dictionary_put (ctx, dict, name.datum.name, &operator); 234| 1.00M|} cairo-script-interpreter.c:_add_integer_constant: 240| 442k|{ 241| 442k| csi_object_t name; 242| 442k| csi_object_t constant; 243| 442k| csi_status_t status; 244| | 245| 442k| status = csi_name_new_static (ctx, &name, def->name); 246| 442k| if (status) ------------------ | Branch (246:9): [True: 0, False: 442k] ------------------ 247| 0| return status; 248| | 249| 442k| csi_integer_new (&constant, def->value); 250| | 251| 442k| return csi_dictionary_put (ctx, dict, name.datum.name, &constant); 252| 442k|} cairo-script-interpreter.c:_add_real_constant: 258| 20.5k|{ 259| 20.5k| csi_object_t name; 260| 20.5k| csi_object_t constant; 261| 20.5k| csi_status_t status; 262| | 263| 20.5k| status = csi_name_new_static (ctx, &name, def->name); 264| 20.5k| if (status) ------------------ | Branch (264:9): [True: 0, False: 20.5k] ------------------ 265| 0| return status; 266| | 267| 20.5k| csi_real_new (&constant, def->value); 268| | 269| 20.5k| return csi_dictionary_put (ctx, dict, name.datum.name, &constant); 270| 20.5k|} cairo-script-interpreter.c:_csi_finish: 438| 5.14k|{ 439| 5.14k| _csi_stack_fini (ctx, &ctx->ostack); 440| 5.14k| _csi_stack_fini (ctx, &ctx->dstack); 441| 5.14k| _csi_scanner_fini (ctx, &ctx->scanner); 442| | 443| 5.14k| _csi_hash_table_fini (&ctx->strings); 444| 5.14k|} cairo-script-interpreter.c:_csi_fini: 658| 5.14k|{ 659| 5.14k| if (! ctx->finished) ------------------ | Branch (659:9): [True: 0, False: 5.14k] ------------------ 660| 0| _csi_finish (ctx); 661| | 662| 5.14k| if (ctx->free_array != NULL) ------------------ | Branch (662:9): [True: 759, False: 4.38k] ------------------ 663| 759| csi_array_free (ctx, ctx->free_array); 664| 5.14k| if (ctx->free_dictionary != NULL) ------------------ | Branch (664:9): [True: 5.14k, False: 0] ------------------ 665| 5.14k| csi_dictionary_free (ctx, ctx->free_dictionary); 666| 5.14k| if (ctx->free_string != NULL) ------------------ | Branch (666:9): [True: 468, False: 4.68k] ------------------ 667| 468| csi_string_free (ctx, ctx->free_string); 668| | 669| 5.14k| _csi_slab_fini (ctx); 670| 5.14k| _csi_perm_fini (ctx); 671| 5.14k|} cairo-script-interpreter.c:_csi_slab_fini: 206| 5.14k|{ 207| 5.14k| unsigned int i; 208| | 209| 87.5k| for (i = 0; i < sizeof (ctx->slabs) / sizeof (ctx->slabs[0]); i++) { ------------------ | Branch (209:17): [True: 82.3k, False: 5.14k] ------------------ 210| 104k| while (ctx->slabs[i].chunk != NULL) { ------------------ | Branch (210:9): [True: 22.5k, False: 82.3k] ------------------ 211| 22.5k| csi_chunk_t *chunk = ctx->slabs[i].chunk; 212| 22.5k| ctx->slabs[i].chunk = chunk->next; 213| 22.5k| _csi_free (ctx, chunk); 214| 22.5k| } 215| 82.3k| } 216| 5.14k|} cairo-script-interpreter.c:_csi_perm_fini: 196| 5.14k|{ 197| 15.5k| while (ctx->perm_chunk != NULL) { ------------------ | Branch (197:12): [True: 10.3k, False: 5.14k] ------------------ 198| 10.3k| csi_chunk_t *chunk = ctx->perm_chunk; 199| 10.3k| ctx->perm_chunk = chunk->next; 200| 10.3k| _csi_free (ctx, chunk); 201| 10.3k| } 202| 5.14k|} csi_array_new: 47| 1.25M|{ 48| 1.25M| csi_array_t *array; 49| | 50| 1.25M| if (ctx->free_array == NULL || ------------------ | Branch (50:9): [True: 1.25M, False: 1.12k] ------------------ 51| 1.12k| ctx->free_array->stack.size <= initial_size) ------------------ | Branch (51:2): [True: 0, False: 1.12k] ------------------ 52| 1.25M| { 53| 1.25M| csi_status_t status; 54| | 55| 1.25M| array = _csi_slab_alloc (ctx, sizeof (csi_array_t)); 56| 1.25M| if (_csi_unlikely (array == NULL)) ------------------ | | 120| 1.25M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.25M| __extension__ ({ \ | | | | 112| 1.25M| int _csi_boolean_var_; \ | | | | 113| 1.25M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.25M] | | | | ------------------ | | | | 114| 1.25M| _csi_boolean_var_ = 1; \ | | | | 115| 1.25M| else \ | | | | 116| 1.25M| _csi_boolean_var_ = 0; \ | | | | 117| 1.25M| _csi_boolean_var_; \ | | | | 118| 1.25M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.25M] | | ------------------ ------------------ 57| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 58| | 59| 1.25M| status = _csi_stack_init (ctx, &array->stack, 60| 1.25M| initial_size ? initial_size : 32); ------------------ | Branch (60:7): [True: 250k, False: 1.00M] ------------------ 61| 1.25M| if (_csi_unlikely (status)) { ------------------ | | 120| 1.25M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.25M| __extension__ ({ \ | | | | 112| 1.25M| int _csi_boolean_var_; \ | | | | 113| 1.25M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.25M] | | | | ------------------ | | | | 114| 1.25M| _csi_boolean_var_ = 1; \ | | | | 115| 1.25M| else \ | | | | 116| 1.25M| _csi_boolean_var_ = 0; \ | | | | 117| 1.25M| _csi_boolean_var_; \ | | | | 118| 1.25M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.25M] | | ------------------ ------------------ 62| 0| _csi_slab_free (ctx, array, sizeof (csi_array_t)); 63| 0| return status; 64| 0| } 65| 1.25M| } else { 66| 1.12k| array = ctx->free_array; 67| 1.12k| ctx->free_array = NULL; 68| 1.12k| } 69| | 70| 1.25M| array->base.type = CSI_OBJECT_TYPE_ARRAY; 71| 1.25M| array->base.ref = 1; 72| | 73| 1.25M| obj->type = CSI_OBJECT_TYPE_ARRAY; 74| 1.25M| obj->datum.array = array; 75| | 76| 1.25M| return CSI_STATUS_SUCCESS; 77| 1.25M|} csi_array_append: 126| 855k|{ 127| 855k| return _csi_stack_push (ctx, &array->stack, csi_object_reference (obj)); 128| 855k|} csi_array_free: 161| 1.25M|{ 162| |#if CSI_DEBUG_MALLOC 163| | _csi_stack_fini (ctx, &array->stack); 164| | _csi_slab_free (ctx, array, sizeof (csi_array_t)); 165| |#else 166| 1.25M| csi_integer_t n; 167| | 168| 2.35M| for (n = 0; n < array->stack.len; n++) ------------------ | Branch (168:17): [True: 1.10M, False: 1.25M] ------------------ 169| 1.10M| csi_object_free (ctx, &array->stack.objects[n]); 170| 1.25M| array->stack.len = 0; 171| | 172| 1.25M| if (ctx->free_array != NULL) { ------------------ | Branch (172:9): [True: 1.24M, False: 1.88k] ------------------ 173| 1.24M| if (array->stack.size > ctx->free_array->stack.size) { ------------------ | Branch (173:6): [True: 85, False: 1.24M] ------------------ 174| 85| csi_array_t *tmp = ctx->free_array; 175| 85| ctx->free_array = array; 176| 85| array = tmp; 177| 85| } 178| | 179| 1.24M| _csi_stack_fini (ctx, &array->stack); 180| 1.24M| _csi_slab_free (ctx, array, sizeof (csi_array_t)); 181| 1.24M| } else 182| 1.88k| ctx->free_array = array; 183| 1.25M|#endif 184| 1.25M|} csi_dictionary_new: 196| 96.5k|{ 197| 96.5k| csi_dictionary_t *dict; 198| | 199| 96.5k| if (ctx->free_dictionary != NULL) { ------------------ | Branch (199:9): [True: 5.65k, False: 90.8k] ------------------ 200| 5.65k| dict = ctx->free_dictionary; 201| 5.65k| ctx->free_dictionary = NULL; 202| 90.8k| } else { 203| 90.8k| csi_status_t status; 204| | 205| 90.8k| dict = _csi_slab_alloc (ctx, sizeof (csi_dictionary_t)); 206| 90.8k| if (_csi_unlikely (dict == NULL)) ------------------ | | 120| 90.8k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 90.8k| __extension__ ({ \ | | | | 112| 90.8k| int _csi_boolean_var_; \ | | | | 113| 90.8k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 90.8k] | | | | ------------------ | | | | 114| 90.8k| _csi_boolean_var_ = 1; \ | | | | 115| 90.8k| else \ | | | | 116| 90.8k| _csi_boolean_var_ = 0; \ | | | | 117| 90.8k| _csi_boolean_var_; \ | | | | 118| 90.8k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 90.8k] | | ------------------ ------------------ 207| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 208| | 209| 90.8k| status = _csi_hash_table_init (&dict->hash_table, 210| 90.8k| _dictionary_name_equal); 211| 90.8k| if (_csi_unlikely (status)) { ------------------ | | 120| 90.8k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 90.8k| __extension__ ({ \ | | | | 112| 90.8k| int _csi_boolean_var_; \ | | | | 113| 90.8k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 90.8k] | | | | ------------------ | | | | 114| 90.8k| _csi_boolean_var_ = 1; \ | | | | 115| 90.8k| else \ | | | | 116| 90.8k| _csi_boolean_var_ = 0; \ | | | | 117| 90.8k| _csi_boolean_var_; \ | | | | 118| 90.8k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 90.8k] | | ------------------ ------------------ 212| 0| _csi_slab_free (ctx, dict, sizeof (csi_dictionary_t)); 213| 0| return status; 214| 0| } 215| 90.8k| } 216| | 217| 96.5k| dict->base.type = CSI_OBJECT_TYPE_DICTIONARY; 218| 96.5k| dict->base.ref = 1; 219| | 220| 96.5k| obj->type = CSI_OBJECT_TYPE_DICTIONARY; 221| 96.5k| obj->datum.dictionary = dict; 222| | 223| 96.5k| return CSI_STATUS_SUCCESS; 224| 96.5k|} csi_dictionary_free: 248| 101k|{ 249| 101k| struct _dictionary_entry_pluck data; 250| | 251| 101k| data.ctx = ctx; 252| 101k| data.hash_table = &dict->hash_table; 253| 101k| _csi_hash_table_foreach (&dict->hash_table, 254| 101k| _dictionary_entry_pluck, 255| 101k| &data); 256| | 257| |#if CSI_DEBUG_MALLOC 258| | _csi_hash_table_fini (&dict->hash_table); 259| | _csi_slab_free (ctx, dict, sizeof (csi_dictionary_t)); 260| |#else 261| 101k| if (ctx->free_dictionary != NULL) { ------------------ | Branch (261:9): [True: 90.8k, False: 10.8k] ------------------ 262| 90.8k| _csi_hash_table_fini (&dict->hash_table); 263| 90.8k| _csi_slab_free (ctx, dict, sizeof (csi_dictionary_t)); 264| 90.8k| } else 265| 10.8k| ctx->free_dictionary = dict; 266| 101k|#endif 267| 101k|} csi_dictionary_put: 274| 2.18M|{ 275| 2.18M| csi_dictionary_entry_t *entry; 276| 2.18M| csi_status_t status; 277| | 278| 2.18M| entry = _csi_hash_table_lookup (&dict->hash_table, 279| 2.18M| (csi_hash_entry_t *) &name); 280| 2.18M| if (entry != NULL) { ------------------ | Branch (280:9): [True: 38, False: 2.18M] ------------------ 281| | /* replace the existing entry */ 282| 38| csi_object_free (ctx, &entry->value); 283| 38| entry->value = *csi_object_reference (value); 284| 38| return CSI_STATUS_SUCCESS; 285| 38| } 286| | 287| 2.18M| entry = _csi_slab_alloc (ctx, sizeof (*entry)); 288| 2.18M| if (_csi_unlikely (entry == NULL)) ------------------ | | 120| 2.18M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.18M| __extension__ ({ \ | | | | 112| 2.18M| int _csi_boolean_var_; \ | | | | 113| 2.18M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 2.18M] | | | | ------------------ | | | | 114| 2.18M| _csi_boolean_var_ = 1; \ | | | | 115| 2.18M| else \ | | | | 116| 2.18M| _csi_boolean_var_ = 0; \ | | | | 117| 2.18M| _csi_boolean_var_; \ | | | | 118| 2.18M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 2.18M] | | ------------------ ------------------ 289| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 290| | 291| 2.18M| entry->hash_entry.hash = name; 292| 2.18M| status = _csi_hash_table_insert (&dict->hash_table, &entry->hash_entry); 293| 2.18M| if (_csi_unlikely (status)) { ------------------ | | 120| 2.18M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.18M| __extension__ ({ \ | | | | 112| 2.18M| int _csi_boolean_var_; \ | | | | 113| 2.18M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 2.18M] | | | | ------------------ | | | | 114| 2.18M| _csi_boolean_var_ = 1; \ | | | | 115| 2.18M| else \ | | | | 116| 2.18M| _csi_boolean_var_ = 0; \ | | | | 117| 2.18M| _csi_boolean_var_; \ | | | | 118| 2.18M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 2.18M] | | ------------------ ------------------ 294| 0| _csi_slab_free (ctx, entry, sizeof (*entry)); 295| 0| return status; 296| 0| } 297| | 298| 2.18M| entry->value = *csi_object_reference (value); 299| | 300| 2.18M| return CSI_STATUS_SUCCESS; 301| 2.18M|} csi_dictionary_get: 308| 5|{ 309| 5| csi_dictionary_entry_t *entry; 310| | 311| 5| entry = _csi_hash_table_lookup (&dict->hash_table, 312| 5| (csi_hash_entry_t *) &name); 313| 5| if (_csi_unlikely (entry == NULL)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 314| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 315| | 316| 0| *value = entry->value; 317| 0| return CSI_STATUS_SUCCESS; 318| 5|} csi_dictionary_has: 323| 1.00M|{ 324| 1.00M| return _csi_hash_table_lookup (&dict->hash_table, 325| | (csi_hash_entry_t *) &name) != NULL; 326| 1.00M|} csi_matrix_new: 347| 330|{ 348| 330| csi_matrix_t *matrix; 349| | 350| 330| matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t)); 351| 330| if (_csi_unlikely (matrix == NULL)) ------------------ | | 120| 330|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 330| __extension__ ({ \ | | | | 112| 330| int _csi_boolean_var_; \ | | | | 113| 330| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 330] | | | | ------------------ | | | | 114| 330| _csi_boolean_var_ = 1; \ | | | | 115| 330| else \ | | | | 116| 330| _csi_boolean_var_ = 0; \ | | | | 117| 330| _csi_boolean_var_; \ | | | | 118| 330|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 330] | | ------------------ ------------------ 352| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 353| | 354| 330| matrix->base.type = CSI_OBJECT_TYPE_MATRIX; 355| 330| matrix->base.ref = 1; 356| 330| cairo_matrix_init_identity (&matrix->matrix); 357| | 358| 330| obj->type = CSI_OBJECT_TYPE_MATRIX; 359| 330| obj->datum.matrix = matrix; 360| | 361| 330| return CSI_STATUS_SUCCESS; 362| 330|} csi_matrix_new_from_array: 368| 1|{ 369| 1| csi_matrix_t *matrix; 370| | 371| 1| if (_csi_unlikely (array->stack.len != 6)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 372| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 373| | 374| 0| matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t)); 375| 0| if (_csi_unlikely (matrix == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 376| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 377| | 378| 0| matrix->base.type = CSI_OBJECT_TYPE_MATRIX; 379| 0| matrix->base.ref = 1; 380| 0| cairo_matrix_init (&matrix->matrix, 381| 0| csi_number_get_value (&array->stack.objects[0]), 382| 0| csi_number_get_value (&array->stack.objects[1]), 383| 0| csi_number_get_value (&array->stack.objects[2]), 384| 0| csi_number_get_value (&array->stack.objects[3]), 385| 0| csi_number_get_value (&array->stack.objects[4]), 386| 0| csi_number_get_value (&array->stack.objects[5])); 387| | 388| 0| obj->type = CSI_OBJECT_TYPE_MATRIX; 389| 0| obj->datum.matrix = matrix; 390| | 391| 0| return CSI_STATUS_SUCCESS; 392| 0|} csi_matrix_new_from_matrix: 398| 1|{ 399| 1| csi_matrix_t *matrix; 400| | 401| 1| matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t)); 402| 1| if (_csi_unlikely (matrix == NULL)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1] | | ------------------ ------------------ 403| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 404| | 405| 1| matrix->base.type = CSI_OBJECT_TYPE_MATRIX; 406| 1| matrix->base.ref = 1; 407| 1| matrix->matrix = *m; 408| | 409| 1| obj->type = CSI_OBJECT_TYPE_MATRIX; 410| 1| obj->datum.matrix = matrix; 411| | 412| 1| return CSI_STATUS_SUCCESS; 413| 1|} csi_matrix_new_from_values: 419| 1.15k|{ 420| 1.15k| csi_matrix_t *matrix; 421| | 422| 1.15k| matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t)); 423| 1.15k| if (_csi_unlikely (matrix == NULL)) ------------------ | | 120| 1.15k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.15k| __extension__ ({ \ | | | | 112| 1.15k| int _csi_boolean_var_; \ | | | | 113| 1.15k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.15k] | | | | ------------------ | | | | 114| 1.15k| _csi_boolean_var_ = 1; \ | | | | 115| 1.15k| else \ | | | | 116| 1.15k| _csi_boolean_var_ = 0; \ | | | | 117| 1.15k| _csi_boolean_var_; \ | | | | 118| 1.15k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.15k] | | ------------------ ------------------ 424| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 425| | 426| 1.15k| matrix->base.type = CSI_OBJECT_TYPE_MATRIX; 427| 1.15k| matrix->base.ref = 1; 428| 1.15k| cairo_matrix_init (&matrix->matrix, v[0], v[1], v[2], v[3], v[4], v[5]); 429| | 430| 1.15k| obj->type = CSI_OBJECT_TYPE_MATRIX; 431| 1.15k| obj->datum.matrix = matrix; 432| | 433| 1.15k| return CSI_STATUS_SUCCESS; 434| 1.15k|} csi_matrix_free: 439| 1.48k|{ 440| 1.48k| _csi_slab_free (ctx, obj, sizeof (csi_matrix_t)); 441| 1.48k|} csi_name_new: 449| 4.31M|{ 450| 4.31M| csi_status_t status; 451| | 452| 4.31M| status = _csi_intern_string (ctx, &str, len); 453| 4.31M| if (_csi_unlikely (status)) ------------------ | | 120| 4.31M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.31M| __extension__ ({ \ | | | | 112| 4.31M| int _csi_boolean_var_; \ | | | | 113| 4.31M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4.31M] | | | | ------------------ | | | | 114| 4.31M| _csi_boolean_var_ = 1; \ | | | | 115| 4.31M| else \ | | | | 116| 4.31M| _csi_boolean_var_ = 0; \ | | | | 117| 4.31M| _csi_boolean_var_; \ | | | | 118| 4.31M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4.31M] | | ------------------ ------------------ 454| 0| return status; 455| | 456| 4.31M| obj->type = CSI_OBJECT_TYPE_NAME; 457| 4.31M| obj->datum.name = (csi_name_t) str; 458| | 459| 4.31M| return CSI_STATUS_SUCCESS; 460| 4.31M|} csi_name_new_static: 466| 1.46M|{ 467| 1.46M| csi_status_t status; 468| | 469| 1.46M| status = _csi_intern_string (ctx, &str, strlen (str)); 470| 1.46M| if (_csi_unlikely (status)) ------------------ | | 120| 1.46M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.46M| __extension__ ({ \ | | | | 112| 1.46M| int _csi_boolean_var_; \ | | | | 113| 1.46M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.46M] | | | | ------------------ | | | | 114| 1.46M| _csi_boolean_var_ = 1; \ | | | | 115| 1.46M| else \ | | | | 116| 1.46M| _csi_boolean_var_ = 0; \ | | | | 117| 1.46M| _csi_boolean_var_; \ | | | | 118| 1.46M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.46M] | | ------------------ ------------------ 471| 0| return status; 472| | 473| 1.46M| obj->type = CSI_OBJECT_TYPE_NAME; 474| 1.46M| obj->datum.name = (csi_name_t) str; 475| | 476| 1.46M| return CSI_STATUS_SUCCESS; 477| 1.46M|} csi_string_new: 484| 206k|{ 485| 206k| csi_string_t *string; 486| | 487| 206k| if (len < 0) ------------------ | Branch (487:9): [True: 347, False: 206k] ------------------ 488| 347| len = strlen (str); 489| 206k| if (_csi_unlikely (len >= INT_MAX)) ------------------ | | 120| 206k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 206k| __extension__ ({ \ | | | | 112| 206k| int _csi_boolean_var_; \ | | | | 113| 206k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 206k] | | | | ------------------ | | | | 114| 206k| _csi_boolean_var_ = 1; \ | | | | 115| 206k| else \ | | | | 116| 206k| _csi_boolean_var_ = 0; \ | | | | 117| 206k| _csi_boolean_var_; \ | | | | 118| 206k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 206k] | | ------------------ ------------------ 490| 1| return _csi_error (CSI_STATUS_NO_MEMORY); 491| | 492| 206k| if (ctx->free_string == NULL || ctx->free_string->len <= len) { ------------------ | Branch (492:9): [True: 109k, False: 97.3k] | Branch (492:37): [True: 92.0k, False: 5.31k] ------------------ 493| 201k| string = _csi_slab_alloc (ctx, sizeof (csi_string_t)); 494| 201k| if (_csi_unlikely (string == NULL)) ------------------ | | 120| 201k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 201k| __extension__ ({ \ | | | | 112| 201k| int _csi_boolean_var_; \ | | | | 113| 201k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 201k] | | | | ------------------ | | | | 114| 201k| _csi_boolean_var_ = 1; \ | | | | 115| 201k| else \ | | | | 116| 201k| _csi_boolean_var_ = 0; \ | | | | 117| 201k| _csi_boolean_var_; \ | | | | 118| 201k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 201k] | | ------------------ ------------------ 495| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 496| | 497| 201k| string->string = _csi_alloc (ctx, len + 1); 498| 201k| if (_csi_unlikely (string->string == NULL)) { ------------------ | | 120| 201k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 201k| __extension__ ({ \ | | | | 112| 201k| int _csi_boolean_var_; \ | | | | 113| 201k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 201k] | | | | ------------------ | | | | 114| 201k| _csi_boolean_var_ = 1; \ | | | | 115| 201k| else \ | | | | 116| 201k| _csi_boolean_var_ = 0; \ | | | | 117| 201k| _csi_boolean_var_; \ | | | | 118| 201k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 201k] | | ------------------ ------------------ 499| 0| _csi_slab_free (ctx, string, sizeof (csi_string_t)); 500| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 501| 0| } 502| 201k| } else { 503| 5.31k| string = ctx->free_string; 504| 5.31k| ctx->free_string = NULL; 505| 5.31k| } 506| | 507| 206k| if (str != NULL) { ------------------ | Branch (507:9): [True: 202k, False: 3.73k] ------------------ 508| 202k| memcpy (string->string, str, len); 509| 202k| string->string[len] = '\0'; 510| 202k| } 511| 206k| string->len = len; 512| 206k| string->deflate = 0; 513| 206k| string->method = NONE; 514| | 515| 206k| string->base.type = CSI_OBJECT_TYPE_STRING; 516| 206k| string->base.ref = 1; 517| | 518| 206k| obj->type = CSI_OBJECT_TYPE_STRING; 519| 206k| obj->datum.string = string; 520| | 521| 206k| return CSI_STATUS_SUCCESS; 522| 206k|} csi_string_deflate_new: 530| 349|{ 531| 349| csi_status_t status; 532| 349| csi_string_t *string; 533| | 534| 349| status = csi_string_new (ctx, obj, bytes, in_len); 535| 349| if (_csi_unlikely (status)) ------------------ | | 120| 349|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 349| __extension__ ({ \ | | | | 112| 349| int _csi_boolean_var_; \ | | | | 113| 349| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 349] | | | | ------------------ | | | | 114| 349| _csi_boolean_var_ = 1; \ | | | | 115| 349| else \ | | | | 116| 349| _csi_boolean_var_ = 0; \ | | | | 117| 349| _csi_boolean_var_; \ | | | | 118| 349|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 349] | | ------------------ ------------------ 536| 0| return status; 537| | 538| 349| string = obj->datum.string; 539| 349| string->deflate = out_len; 540| 349| string->method = ZLIB; 541| | 542| 349| return CSI_STATUS_SUCCESS; 543| 349|} csi_string_free: 595| 190k|{ 596| |#if CSI_DEBUG_MALLOC 597| | _csi_free (ctx, string->string); 598| | _csi_slab_free (ctx, string, sizeof (csi_string_t)); 599| |#else 600| 190k| if (ctx->free_string != NULL) { ------------------ | Branch (600:9): [True: 185k, False: 5.78k] ------------------ 601| 185k| if (string->len > ctx->free_string->len) { ------------------ | Branch (601:6): [True: 1.82k, False: 183k] ------------------ 602| 1.82k| csi_string_t *tmp = ctx->free_string; 603| 1.82k| ctx->free_string = string; 604| 1.82k| string = tmp; 605| 1.82k| } 606| | 607| 185k| _csi_free (ctx, string->string); 608| 185k| _csi_slab_free (ctx, string, sizeof (csi_string_t)); 609| 185k| } else 610| 5.78k| ctx->free_string = string; 611| 190k|#endif 612| 190k|} csi_object_execute: 616| 4.02M|{ 617| 4.02M| csi_status_t status; 618| 4.02M| csi_object_t indirect; 619| | 620| 7.52M| INDIRECT: 621| 7.52M| switch (obj->type & CSI_OBJECT_TYPE_MASK) { ------------------ | | 253| 7.52M|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 7.52M|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 7.52M| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ 622| 3.49M| case CSI_OBJECT_TYPE_NAME: ------------------ | Branch (622:5): [True: 3.49M, False: 4.02M] ------------------ 623| 3.49M| status = _csi_name_lookup (ctx, obj->datum.name, &indirect); 624| 3.49M| if (_csi_unlikely (status)) ------------------ | | 120| 3.49M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.49M| __extension__ ({ \ | | | | 112| 3.49M| int _csi_boolean_var_; \ | | | | 113| 3.49M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 781, False: 3.49M] | | | | ------------------ | | | | 114| 3.49M| _csi_boolean_var_ = 1; \ | | | | 115| 3.49M| else \ | | | | 116| 3.49M| _csi_boolean_var_ = 0; \ | | | | 117| 3.49M| _csi_boolean_var_; \ | | | | 118| 3.49M|}) | | ------------------ | | | Branch (120:29): [True: 781, False: 3.49M] | | ------------------ ------------------ 625| 781| return status; 626| 3.49M| if (indirect.type & CSI_OBJECT_ATTR_EXECUTABLE) { ------------------ | Branch (626:6): [True: 3.49M, False: 1] ------------------ 627| 3.49M| obj = &indirect; 628| 3.49M| goto INDIRECT; 629| 3.49M| } else 630| 1| return _csi_push_ostack_copy (ctx, &indirect); 631| | 632| 4.02M| case CSI_OBJECT_TYPE_OPERATOR: ------------------ | Branch (632:5): [True: 4.02M, False: 3.50M] ------------------ 633| 4.02M| return obj->datum.op (ctx); 634| | 635| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (635:5): [True: 0, False: 7.52M] ------------------ 636| 0| return _csi_array_execute (ctx, obj->datum.array); 637| 5.14k| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (637:5): [True: 5.14k, False: 7.51M] ------------------ 638| 5.14k| return _csi_file_execute (ctx, obj->datum.file); 639| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (639:5): [True: 0, False: 7.52M] ------------------ 640| 0| return _csi_string_execute (ctx, obj->datum.string); 641| | 642| 0| default: ------------------ | Branch (642:5): [True: 0, False: 7.52M] ------------------ 643| 0| return _csi_push_ostack_copy (ctx, obj); 644| 7.52M| } 645| 7.52M|} csi_object_reference: 649| 3.05M|{ 650| 3.05M| if (CSI_OBJECT_IS_CAIRO (obj)) { ------------------ | | 245| 3.05M|#define CSI_OBJECT_IS_CAIRO(OBJ) ((OBJ)->type & 0x10) | | ------------------ | | | Branch (245:34): [True: 21, False: 3.05M] | | ------------------ ------------------ 651| 21| switch (obj->type & CSI_OBJECT_TYPE_MASK) { ------------------ | | 253| 21|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 21|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 21| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ | Branch (651:10): [True: 21, False: 0] ------------------ 652| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (652:2): [True: 0, False: 21] ------------------ 653| 0| cairo_reference (obj->datum.cr); 654| 0| break; 655| 0| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (655:2): [True: 0, False: 21] ------------------ 656| 0| cairo_font_face_reference (obj->datum.font_face); 657| 0| break; 658| 21| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (658:2): [True: 21, False: 0] ------------------ 659| 21| cairo_pattern_reference (obj->datum.pattern); 660| 21| break; 661| 0| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (661:2): [True: 0, False: 21] ------------------ 662| 0| cairo_scaled_font_reference (obj->datum.scaled_font); 663| 0| break; 664| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (664:2): [True: 0, False: 21] ------------------ 665| 0| cairo_surface_reference (obj->datum.surface); 666| 0| break; 667| 21| } 668| 3.05M| } else if (CSI_OBJECT_IS_COMPOUND (obj)) { ------------------ | | 244| 3.05M|#define CSI_OBJECT_IS_COMPOUND(OBJ) ((OBJ)->type & 0x08) | | ------------------ | | | Branch (244:37): [True: 26.5k, False: 3.02M] | | ------------------ ------------------ 669| 26.5k| obj->datum.object->ref++; 670| 26.5k| } 671| | 672| 3.05M| return obj; 673| 3.05M|} csi_object_free: 678| 12.6M|{ 679| 12.6M| if (CSI_OBJECT_IS_CAIRO (obj)) { ------------------ | | 245| 12.6M|#define CSI_OBJECT_IS_CAIRO(OBJ) ((OBJ)->type & 0x10) | | ------------------ | | | Branch (245:34): [True: 43.0k, False: 12.6M] | | ------------------ ------------------ 680| 43.0k| switch (obj->type & CSI_OBJECT_TYPE_MASK) { ------------------ | | 253| 43.0k|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 43.0k|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 43.0k| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ | Branch (680:10): [True: 43.0k, False: 0] ------------------ 681| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (681:2): [True: 0, False: 43.0k] ------------------ 682| 0| cairo_destroy (obj->datum.cr); 683| 0| break; 684| 0| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (684:2): [True: 0, False: 43.0k] ------------------ 685| 0| cairo_font_face_destroy (obj->datum.font_face); 686| 0| break; 687| 43.0k| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (687:2): [True: 43.0k, False: 1] ------------------ 688| 43.0k| cairo_pattern_destroy (obj->datum.pattern); 689| 43.0k| break; 690| 0| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (690:2): [True: 0, False: 43.0k] ------------------ 691| 0| cairo_scaled_font_destroy (obj->datum.scaled_font); 692| 0| break; 693| 1| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (693:2): [True: 1, False: 43.0k] ------------------ 694| 1| cairo_surface_destroy (obj->datum.surface); 695| 1| break; 696| 43.0k| } 697| 12.6M| } else if (CSI_OBJECT_IS_COMPOUND (obj)) { ------------------ | | 244| 12.6M|#define CSI_OBJECT_IS_COMPOUND(OBJ) ((OBJ)->type & 0x08) | | ------------------ | | | Branch (244:37): [True: 1.56M, False: 11.0M] | | ------------------ ------------------ 698| 1.56M| if (--obj->datum.object->ref) ------------------ | Branch (698:6): [True: 26.5k, False: 1.53M] ------------------ 699| 26.5k| return; 700| | 701| 1.53M| switch (obj->type & CSI_OBJECT_TYPE_MASK) { ------------------ | | 253| 1.53M|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 1.53M|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 1.53M| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ 702| 1.25M| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (702:2): [True: 1.25M, False: 288k] ------------------ 703| 1.25M| csi_array_free (ctx, obj->datum.array); 704| 1.25M| break; 705| 91.3k| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (705:2): [True: 91.3k, False: 1.44M] ------------------ 706| 91.3k| csi_dictionary_free (ctx, obj->datum.dictionary); 707| 91.3k| break; 708| 5.14k| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (708:2): [True: 5.14k, False: 1.53M] ------------------ 709| 5.14k| _csi_file_free (ctx, obj->datum.file); 710| 5.14k| break; 711| 1.48k| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (711:2): [True: 1.48k, False: 1.53M] ------------------ 712| 1.48k| csi_matrix_free (ctx, obj->datum.matrix); 713| 1.48k| break; 714| 190k| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (714:2): [True: 190k, False: 1.34M] ------------------ 715| 190k| csi_string_free (ctx, obj->datum.string); 716| 190k| break; 717| 0| default: ------------------ | Branch (717:2): [True: 0, False: 1.53M] ------------------ 718| 0| break; 719| 1.53M| } 720| 1.53M| } 721| 12.6M|} csi_object_eq: 761| 239k|{ 762| 239k| csi_object_type_t atype = csi_object_get_type (a); 763| 239k| csi_object_type_t btype = csi_object_get_type (b); 764| | 765| 239k| if (atype == btype) { ------------------ | Branch (765:9): [True: 198k, False: 40.7k] ------------------ 766| 198k| switch (atype) { ------------------ | Branch (766:10): [True: 198k, False: 0] ------------------ 767| 13.6k| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (767:2): [True: 13.6k, False: 185k] ------------------ 768| 13.6k| return a->datum.boolean == b->datum.boolean; 769| 35.3k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (769:2): [True: 35.3k, False: 163k] ------------------ 770| 35.3k| return a->datum.integer == b->datum.integer; 771| 140k| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (771:2): [True: 140k, False: 57.9k] ------------------ 772| 140k| return a->datum.real == b->datum.real; 773| 11| case CSI_OBJECT_TYPE_NAME: ------------------ | Branch (773:2): [True: 11, False: 198k] ------------------ 774| 11| return a->datum.name == b->datum.name; 775| 6.63k| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (775:2): [True: 6.63k, False: 192k] ------------------ 776| 6.63k| return 0 == lexcmp (a->datum.string->string, 777| 6.63k| a->datum.string->len, 778| 6.63k| b->datum.string->string, 779| 6.63k| b->datum.string->len); 780| 3| case CSI_OBJECT_TYPE_NULL: ------------------ | Branch (780:2): [True: 3, False: 198k] ------------------ 781| 727| case CSI_OBJECT_TYPE_MARK: ------------------ | Branch (781:2): [True: 724, False: 198k] ------------------ 782| 727| return TRUE; ------------------ | | 55| 727|#define TRUE (!FALSE) | | ------------------ | | | | 51| 727|#define FALSE 0 | | ------------------ ------------------ 783| 6| case CSI_OBJECT_TYPE_OPERATOR: ------------------ | Branch (783:2): [True: 6, False: 198k] ------------------ 784| 6| return a->datum.op == b->datum.op; 785| 49| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (785:2): [True: 49, False: 198k] ------------------ 786| 554| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (786:2): [True: 505, False: 198k] ------------------ 787| 554| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (787:2): [True: 0, False: 198k] ------------------ 788| 556| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (788:2): [True: 2, False: 198k] ------------------ 789| 556| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (789:2): [True: 0, False: 198k] ------------------ 790| 556| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (790:2): [True: 0, False: 198k] ------------------ 791| 1.54k| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (791:2): [True: 992, False: 197k] ------------------ 792| 1.54k| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (792:2): [True: 0, False: 198k] ------------------ 793| 1.54k| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (793:2): [True: 0, False: 198k] ------------------ 794| 1.54k| return a->datum.ptr == b->datum.ptr; 795| 198k| } 796| 198k| } 797| | 798| 40.7k| if (atype < btype) { ------------------ | Branch (798:9): [True: 35.7k, False: 5.04k] ------------------ 799| 35.7k| csi_object_t *c; 800| 35.7k| csi_object_type_t ctype; 801| 35.7k| c = a; a = b; b = c; 802| 35.7k| ctype = atype; atype = btype; btype = ctype; 803| 35.7k| } 804| | 805| 40.7k| switch ((int) atype) { 806| 13.6k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (806:5): [True: 13.6k, False: 27.1k] ------------------ 807| 13.6k| if (btype == CSI_OBJECT_TYPE_BOOLEAN) { ------------------ | Branch (807:6): [True: 13.6k, False: 1] ------------------ 808| 13.6k| return a->datum.integer == b->datum.boolean; 809| 13.6k| } 810| 1| break; 811| 24.2k| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (811:5): [True: 24.2k, False: 16.4k] ------------------ 812| 24.2k| if (btype == CSI_OBJECT_TYPE_INTEGER) { ------------------ | Branch (812:6): [True: 18.4k, False: 5.85k] ------------------ 813| 18.4k| return a->datum.real == b->datum.integer; 814| 18.4k| } 815| 5.85k| else if (btype == CSI_OBJECT_TYPE_BOOLEAN) { ------------------ | Branch (815:11): [True: 5.21k, False: 636] ------------------ 816| 5.21k| return a->datum.real == b->datum.boolean; 817| 5.21k| } 818| 636| break; 819| | 820| 1.27k| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (820:5): [True: 1.27k, False: 39.5k] ------------------ 821| 1.27k| if (btype == CSI_OBJECT_TYPE_NAME) { ------------------ | Branch (821:6): [True: 216, False: 1.05k] ------------------ 822| 216| const char *bstr = (const char *) b->datum.name; 823| 216| return 0 == lexcmp (a->datum.string->string, 824| 216| a->datum.string->len, 825| 216| bstr, 826| 216| strlen (bstr)); 827| 216| } 828| 1.05k| break; 829| | 830| 1.58k| default: ------------------ | Branch (830:5): [True: 1.58k, False: 39.1k] ------------------ 831| 1.58k| break; 832| 40.7k| } 833| | 834| 3.27k| return FALSE; ------------------ | | 51| 3.27k|#define FALSE 0 ------------------ 835| 40.7k|} csi_object_compare: 841| 37.5k|{ 842| 37.5k| csi_object_type_t atype = csi_object_get_type (a); 843| 37.5k| csi_object_type_t btype = csi_object_get_type (b); 844| 37.5k| int sign; 845| | 846| 37.5k| if (csi_object_eq (a, b)){ ------------------ | Branch (846:9): [True: 6.27k, False: 31.3k] ------------------ 847| 6.27k| *out = 0; 848| 6.27k| return CSI_STATUS_SUCCESS; 849| 6.27k| } 850| | 851| 31.3k|#define CMP(x,y) ((x) < (y) ? -1 : +1) 852| | 853| 31.3k| if (atype == btype) { ------------------ | Branch (853:9): [True: 29.3k, False: 1.95k] ------------------ 854| 29.3k| switch (atype) { ------------------ | Branch (854:10): [True: 29.3k, False: 0] ------------------ 855| 154| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (855:2): [True: 154, False: 29.1k] ------------------ 856| 154| *out = CMP (a->datum.boolean, b->datum.boolean); ------------------ | | 851| 154|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 8, False: 146] | | ------------------ ------------------ 857| 154| return CSI_STATUS_SUCCESS; 858| 29.1k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (858:2): [True: 29.1k, False: 195] ------------------ 859| 29.1k| *out = CMP (a->datum.integer, b->datum.integer); ------------------ | | 851| 29.1k|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 20.7k, False: 8.35k] | | ------------------ ------------------ 860| 29.1k| return CSI_STATUS_SUCCESS; 861| 21| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (861:2): [True: 21, False: 29.3k] ------------------ 862| 21| *out = CMP (a->datum.real, b->datum.real); ------------------ | | 851| 21|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 21, False: 0] | | ------------------ ------------------ 863| 21| return CSI_STATUS_SUCCESS; 864| 10| case CSI_OBJECT_TYPE_NAME: { ------------------ | Branch (864:2): [True: 10, False: 29.3k] ------------------ 865| 10| const char *x = (char const *) a->datum.name; 866| 10| const char *y = (char const *) b->datum.name; 867| 10| *out = lexcmp (x, strlen(x), y, strlen (y)); 868| 10| return CSI_STATUS_SUCCESS; 869| 0| } 870| 1| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (870:2): [True: 1, False: 29.3k] ------------------ 871| 1| *out = lexcmp (a->datum.string->string, 872| 1| a->datum.string->len, 873| 1| b->datum.string->string, 874| 1| b->datum.string->len); 875| 1| return CSI_STATUS_SUCCESS; 876| 0| case CSI_OBJECT_TYPE_NULL: ------------------ | Branch (876:2): [True: 0, False: 29.3k] ------------------ 877| 0| case CSI_OBJECT_TYPE_MARK: ------------------ | Branch (877:2): [True: 0, False: 29.3k] ------------------ 878| 1| case CSI_OBJECT_TYPE_OPERATOR: ------------------ | Branch (878:2): [True: 1, False: 29.3k] ------------------ 879| 2| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (879:2): [True: 1, False: 29.3k] ------------------ 880| 4| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (880:2): [True: 2, False: 29.3k] ------------------ 881| 4| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (881:2): [True: 0, False: 29.3k] ------------------ 882| 6| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (882:2): [True: 2, False: 29.3k] ------------------ 883| 6| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (883:2): [True: 0, False: 29.3k] ------------------ 884| 6| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (884:2): [True: 0, False: 29.3k] ------------------ 885| 9| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (885:2): [True: 3, False: 29.3k] ------------------ 886| 9| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (886:2): [True: 0, False: 29.3k] ------------------ 887| 9| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (887:2): [True: 0, False: 29.3k] ------------------ 888| 9| goto TYPE_CHECK_ERROR; 889| 29.3k| } 890| 29.3k| } 891| | 892| 1.95k| sign = +1; 893| 1.95k| if (atype < btype) { ------------------ | Branch (893:9): [True: 1.57k, False: 385] ------------------ 894| 1.57k| csi_object_t *c; 895| 1.57k| csi_object_type_t ctype; 896| 1.57k| c = a; a = b; b = c; 897| 1.57k| ctype = atype; atype = btype; btype = ctype; 898| 1.57k| sign = -1; 899| 1.57k| } 900| | 901| 1.95k| switch ((int) atype) { 902| 1.82k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (902:5): [True: 1.82k, False: 130] ------------------ 903| 1.82k| if (btype == CSI_OBJECT_TYPE_BOOLEAN) { ------------------ | Branch (903:6): [True: 1.82k, False: 1] ------------------ 904| 1.82k| *out = sign * CMP (a->datum.integer, !!b->datum.boolean); ------------------ | | 851| 1.82k|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 614, False: 1.21k] | | ------------------ ------------------ 905| 1.82k| return CSI_STATUS_SUCCESS; 906| 1.82k| } 907| 1| break; 908| 116| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (908:5): [True: 116, False: 1.84k] ------------------ 909| 116| if (btype == CSI_OBJECT_TYPE_INTEGER) { ------------------ | Branch (909:6): [True: 111, False: 5] ------------------ 910| 111| *out = sign * CMP (a->datum.real, b->datum.integer); ------------------ | | 851| 111|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 110, False: 1] | | ------------------ ------------------ 911| 111| return CSI_STATUS_SUCCESS; 912| 111| } 913| 5| else if (btype == CSI_OBJECT_TYPE_BOOLEAN) { ------------------ | Branch (913:11): [True: 5, False: 0] ------------------ 914| 5| *out = sign * CMP (a->datum.real, !!b->datum.boolean); ------------------ | | 851| 5|#define CMP(x,y) ((x) < (y) ? -1 : +1) | | ------------------ | | | Branch (851:19): [True: 1, False: 4] | | ------------------ ------------------ 915| 5| return CSI_STATUS_SUCCESS; 916| 5| } 917| 0| break; 918| | 919| 3| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (919:5): [True: 3, False: 1.95k] ------------------ 920| 3| if (btype == CSI_OBJECT_TYPE_NAME) { ------------------ | Branch (920:6): [True: 2, False: 1] ------------------ 921| 2| const char *bstr = (const char *) b->datum.name; 922| 2| *out = sign * lexcmp (a->datum.string->string, 923| 2| a->datum.string->len, 924| 2| bstr, 925| 2| strlen (bstr)); 926| 2| return CSI_STATUS_SUCCESS; 927| 2| } 928| 1| break; 929| | 930| 11| default: ------------------ | Branch (930:5): [True: 11, False: 1.94k] ------------------ 931| 11| break; 932| 1.95k| } 933| | 934| 13|#undef CMP 935| | 936| 22| TYPE_CHECK_ERROR: 937| 22| return _csi_error (CSI_STATUS_SCRIPT_INVALID_TYPE); 938| 1.95k|} cairo-script-objects.c:_dictionary_name_equal: 188| 3.78M|{ 189| 3.78M| return TRUE; ------------------ | | 55| 3.78M|#define TRUE (!FALSE) | | ------------------ | | | | 51| 3.78M|#define FALSE 0 | | ------------------ ------------------ 190| 3.78M|} cairo-script-objects.c:_dictionary_entry_pluck: 233| 2.18M|{ 234| 2.18M| csi_dictionary_entry_t *dict_entry; 235| 2.18M| struct _dictionary_entry_pluck *pluck_data; 236| | 237| 2.18M| dict_entry = entry; 238| 2.18M| pluck_data = data; 239| | 240| 2.18M| _csi_hash_table_remove (pluck_data->hash_table, entry); 241| 2.18M| csi_object_free (pluck_data->ctx, &dict_entry->value); 242| 2.18M| _csi_slab_free (pluck_data->ctx, entry, sizeof (csi_dictionary_entry_t)); 243| 2.18M|} cairo-script-objects.c:lexcmp: 748| 6.86k|{ 749| 6.86k| size_t len = alen < blen ? alen : blen; ------------------ | Branch (749:18): [True: 2.67k, False: 4.19k] ------------------ 750| 6.86k| int cmp = memcmp (a, b, len); 751| 6.86k| if (cmp) ------------------ | Branch (751:9): [True: 553, False: 6.30k] ------------------ 752| 553| return cmp; 753| 6.30k| if (alen == blen) ------------------ | Branch (753:9): [True: 3.06k, False: 3.24k] ------------------ 754| 3.06k| return 0; 755| 3.24k| return alen < blen ? -1 : +1; ------------------ | Branch (755:12): [True: 2.44k, False: 792] ------------------ 756| 6.30k|} _csi_operators: 6701| 5.14k|{ 6702| 5.14k| return _defs; 6703| 5.14k|} _csi_integer_constants: 6814| 5.14k|{ 6815| 5.14k| return _integer_constants; 6816| 5.14k|} _csi_real_constants: 6830| 5.14k|{ 6831| 5.14k| return _real_constants; 6832| 5.14k|} cairo-script-operators.c:_mark: 3615| 3.04M|{ 3616| 3.04M| return _csi_push_ostack_mark (ctx); 3617| 3.04M|} cairo-script-operators.c:end_dict_construction: 585| 15|{ 586| 15| csi_object_t obj; 587| 15| csi_dictionary_t *dict; 588| 15| csi_status_t status; 589| | 590| 15| status = csi_dictionary_new (ctx, &obj); 591| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 15] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 15] | | ------------------ ------------------ 592| 0| return status; 593| | 594| 15| dict = obj.datum.dictionary; 595| 19| do { 596| 19| csi_object_t *name, *value; 597| | 598| 19| check (1); ------------------ | | 93| 19|#define check(CNT) do {\ | | 94| 19| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 19|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 19| __extension__ ({ \ | | | | | | 112| 19| int _csi_boolean_var_; \ | | | | | | 113| 19| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 18] | | | | | | ------------------ | | | | | | 114| 19| _csi_boolean_var_ = 1; \ | | | | | | 115| 19| else \ | | | | | | 116| 19| _csi_boolean_var_ = 0; \ | | | | | | 117| 19| _csi_boolean_var_; \ | | | | | | 118| 19|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 18] | | | | ------------------ | | ------------------ | | 95| 19| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 19|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 18] | | ------------------ ------------------ 599| | 600| 18| value = _csi_peek_ostack (ctx, 0); 601| 18| if (csi_object_get_type (value) == CSI_OBJECT_TYPE_MARK) { ------------------ | Branch (601:6): [True: 4, False: 14] ------------------ 602| 4| pop (1); ------------------ | | 97| 4|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 603| 4| break; 604| 4| } 605| | 606| 14| check (2); ------------------ | | 93| 14|#define check(CNT) do {\ | | 94| 14| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 14| __extension__ ({ \ | | | | | | 112| 14| int _csi_boolean_var_; \ | | | | | | 113| 14| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 12] | | | | | | ------------------ | | | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | | | 115| 14| else \ | | | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | | | 117| 14| _csi_boolean_var_; \ | | | | | | 118| 14|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 12] | | | | ------------------ | | ------------------ | | 95| 14| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 14|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 12] | | ------------------ ------------------ 607| | 608| 12| name = _csi_peek_ostack (ctx, 1); 609| 12| if (_csi_unlikely ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 8, False: 4] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 8, False: 4] | | ------------------ ------------------ 610| 12| (csi_object_get_type (name) != CSI_OBJECT_TYPE_NAME)) 611| 8| { 612| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 613| 8| } 614| | 615| 4| status = csi_dictionary_put (ctx, dict, name->datum.name, value); 616| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4] | | ------------------ ------------------ 617| 0| return status; 618| | 619| 4| pop (2); ------------------ | | 97| 4|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 620| 4| } while (TRUE); ------------------ | | 55| 4|#define TRUE (!FALSE) | | ------------------ | | | | 51| 4|#define FALSE 0 | | ------------------ | | | Branch (55:14): [True: 4, Folded] | | ------------------ ------------------ 621| | 622| 4| return push (&obj); ------------------ | | 98| 4|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 623| 15|} cairo-script-operators.c:end_array_construction: 627| 429k|{ 628| 429k| csi_object_t obj; 629| 429k| csi_status_t status; 630| 429k| int len = 0; 631| | 632| 683k| do { 633| 683k| check (len + 1); ------------------ | | 93| 683k|#define check(CNT) do {\ | | 94| 683k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 683k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 683k| __extension__ ({ \ | | | | | | 112| 683k| int _csi_boolean_var_; \ | | | | | | 113| 683k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 38, False: 683k] | | | | | | ------------------ | | | | | | 114| 683k| _csi_boolean_var_ = 1; \ | | | | | | 115| 683k| else \ | | | | | | 116| 683k| _csi_boolean_var_ = 0; \ | | | | | | 117| 683k| _csi_boolean_var_; \ | | | | | | 118| 683k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 38, False: 683k] | | | | ------------------ | | ------------------ | | 95| 683k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 683k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 683k] | | ------------------ ------------------ 634| | 635| 683k| if (csi_object_get_type (_csi_peek_ostack (ctx, len)) == ------------------ | Branch (635:6): [True: 429k, False: 254k] ------------------ 636| 683k| CSI_OBJECT_TYPE_MARK) 637| 429k| { 638| 429k| break; 639| 429k| } 640| | 641| 254k| len++; 642| 254k| } while (TRUE); ------------------ | | 55| 254k|#define TRUE (!FALSE) | | ------------------ | | | | 51| 254k|#define FALSE 0 | | ------------------ | | | Branch (55:14): [True: 254k, Folded] | | ------------------ ------------------ 643| | 644| 429k| status = csi_array_new (ctx, len, &obj); 645| 429k| if (_csi_unlikely (status)) ------------------ | | 120| 429k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 429k| __extension__ ({ \ | | | | 112| 429k| int _csi_boolean_var_; \ | | | | 113| 429k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 429k] | | | | ------------------ | | | | 114| 429k| _csi_boolean_var_ = 1; \ | | | | 115| 429k| else \ | | | | 116| 429k| _csi_boolean_var_ = 0; \ | | | | 117| 429k| _csi_boolean_var_; \ | | | | 118| 429k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 429k] | | ------------------ ------------------ 646| 0| return status; 647| | 648| 429k| if (len != 0) { ------------------ | Branch (648:9): [True: 250k, False: 179k] ------------------ 649| 250k| csi_array_t *array; 650| | 651| 250k| array = obj.datum.array; 652| 250k| memcpy (array->stack.objects, 653| 250k| _csi_peek_ostack (ctx, len - 1), 654| 250k| sizeof (csi_object_t) * len); 655| 250k| array->stack.len = len; 656| 250k| } 657| 429k| ctx->ostack.len -= len + 1; 658| | 659| 429k| return push (&obj); ------------------ | | 98| 429k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 660| 429k|} cairo-script-operators.c:_alpha: 664| 9.29k|{ 665| 9.29k| csi_object_t obj; 666| 9.29k| csi_status_t status; 667| 9.29k| double a; 668| | 669| 9.29k| check (1); ------------------ | | 93| 9.29k|#define check(CNT) do {\ | | 94| 9.29k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9.29k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9.29k| __extension__ ({ \ | | | | | | 112| 9.29k| int _csi_boolean_var_; \ | | | | | | 113| 9.29k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 9.29k] | | | | | | ------------------ | | | | | | 114| 9.29k| _csi_boolean_var_ = 1; \ | | | | | | 115| 9.29k| else \ | | | | | | 116| 9.29k| _csi_boolean_var_ = 0; \ | | | | | | 117| 9.29k| _csi_boolean_var_; \ | | | | | | 118| 9.29k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 9.29k] | | | | ------------------ | | ------------------ | | 95| 9.29k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9.29k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 9.29k] | | ------------------ ------------------ 670| | 671| 9.29k| status = _csi_ostack_get_number (ctx, 0, &a); 672| 9.29k| if (_csi_unlikely (status)) ------------------ | | 120| 9.29k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9.29k| __extension__ ({ \ | | | | 112| 9.29k| int _csi_boolean_var_; \ | | | | 113| 9.29k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 9.29k] | | | | ------------------ | | | | 114| 9.29k| _csi_boolean_var_ = 1; \ | | | | 115| 9.29k| else \ | | | | 116| 9.29k| _csi_boolean_var_ = 0; \ | | | | 117| 9.29k| _csi_boolean_var_; \ | | | | 118| 9.29k|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 9.29k] | | ------------------ ------------------ 673| 3| return status; 674| | 675| 9.29k| pop (1); ------------------ | | 97| 9.29k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 676| | 677| 9.29k| obj.type = CSI_OBJECT_TYPE_PATTERN; 678| 9.29k| obj.datum.pattern = cairo_pattern_create_rgba (0, 0, 0, a); 679| 9.29k| return push (&obj); ------------------ | | 98| 9.29k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 680| 9.29k|} cairo-script-operators.c:_csi_ostack_get_number: 267| 223k|{ 268| 223k| csi_object_t *obj; 269| 223k| int type; 270| | 271| 223k| obj = _csi_peek_ostack (ctx, i); 272| 223k| type = csi_object_get_type (obj); 273| 223k| switch (type) { 274| 75.5k| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (274:5): [True: 75.5k, False: 147k] ------------------ 275| 75.5k| *out = obj->datum.boolean; 276| 75.5k| break; 277| 48.8k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (277:5): [True: 48.8k, False: 174k] ------------------ 278| 48.8k| *out = obj->datum.integer; 279| 48.8k| break; 280| 98.9k| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (280:5): [True: 98.9k, False: 124k] ------------------ 281| 98.9k| *out = obj->datum.real; 282| 98.9k| break; 283| 169| default: ------------------ | Branch (283:5): [True: 169, False: 223k] ------------------ 284| 169| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 285| 223k| } 286| 223k| return CSI_STATUS_SUCCESS; 287| 223k|} cairo-script-operators.c:_add: 684| 866|{ 685| 866| csi_object_t *A; 686| 866| csi_object_t *B; 687| 866| csi_object_type_t type_a, type_b; 688| | 689| 866| check (2); ------------------ | | 93| 866|#define check(CNT) do {\ | | 94| 866| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 866|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 866| __extension__ ({ \ | | | | | | 112| 866| int _csi_boolean_var_; \ | | | | | | 113| 866| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 864] | | | | | | ------------------ | | | | | | 114| 866| _csi_boolean_var_ = 1; \ | | | | | | 115| 866| else \ | | | | | | 116| 866| _csi_boolean_var_ = 0; \ | | | | | | 117| 866| _csi_boolean_var_; \ | | | | | | 118| 866|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 864] | | | | ------------------ | | ------------------ | | 95| 866| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 866|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 864] | | ------------------ ------------------ 690| | 691| 864| B = _csi_peek_ostack (ctx, 0); 692| 864| A = _csi_peek_ostack (ctx, 1); 693| | 694| 864| type_a = csi_object_get_type (A); 695| 864| if (_csi_unlikely (! (type_a == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 864|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 864| __extension__ ({ \ | | | | 112| 864| int _csi_boolean_var_; \ | | | | 113| 1.73k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 855, False: 9] | | | | | Branch (113:8): [True: 2, False: 7] | | | | ------------------ | | | | 114| 864| _csi_boolean_var_ = 1; \ | | | | 115| 864| else \ | | | | 116| 864| _csi_boolean_var_ = 0; \ | | | | 117| 864| _csi_boolean_var_; \ | | | | 118| 864|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 857] | | ------------------ ------------------ 696| 864| type_a == CSI_OBJECT_TYPE_REAL))) 697| 7| { 698| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 699| 7| } 700| | 701| 857| type_b = csi_object_get_type (B); 702| 857| if (_csi_unlikely (! (type_b == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 857|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 857| __extension__ ({ \ | | | | 112| 857| int _csi_boolean_var_; \ | | | | 113| 1.71k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 852, False: 5] | | | | | Branch (113:8): [True: 2, False: 3] | | | | ------------------ | | | | 114| 857| _csi_boolean_var_ = 1; \ | | | | 115| 857| else \ | | | | 116| 857| _csi_boolean_var_ = 0; \ | | | | 117| 857| _csi_boolean_var_; \ | | | | 118| 857|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 854] | | ------------------ ------------------ 703| 857| type_b == CSI_OBJECT_TYPE_REAL))) 704| 3| { 705| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 706| 3| } 707| | 708| 854| pop (2); ------------------ | | 97| 854|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 709| | 710| 854| if (type_a == CSI_OBJECT_TYPE_REAL && ------------------ | Branch (710:9): [True: 2, False: 852] ------------------ 711| 2| type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (711:2): [True: 1, False: 1] ------------------ 712| 1| { 713| 1| return _csi_push_ostack_real (ctx, A->datum.real + B->datum.real); 714| | 715| 1| } 716| 853| else if (type_a == CSI_OBJECT_TYPE_INTEGER && ------------------ | Branch (716:14): [True: 852, False: 1] ------------------ 717| 852| type_b == CSI_OBJECT_TYPE_INTEGER) ------------------ | Branch (717:7): [True: 851, False: 1] ------------------ 718| 851| { 719| 851| return _csi_push_ostack_integer (ctx, 720| 851| A->datum.integer + B->datum.integer); 721| 851| } 722| 2| else 723| 2| { 724| 2| double v; 725| | 726| 2| if (type_a == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (726:6): [True: 1, False: 1] ------------------ 727| 1| v = A->datum.real; 728| 1| else 729| 1| v = A->datum.integer; 730| | 731| 2| if (type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (731:6): [True: 1, False: 1] ------------------ 732| 1| v += B->datum.real; 733| 1| else 734| 1| v += B->datum.integer; 735| | 736| 2| return _csi_push_ostack_real (ctx, v); 737| 2| } 738| 854|} cairo-script-operators.c:_add_color_stop: 742| 10|{ 743| 10| csi_status_t status; 744| 10| double offset, r, g, b, a; 745| 10| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 746| | 747| 10| check (6); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 8] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 8] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 748| | 749| 8| status = _csi_ostack_get_number (ctx, 0, &a); 750| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 7] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 7] | | ------------------ ------------------ 751| 1| return status; 752| 7| status = _csi_ostack_get_number (ctx, 1, &b); 753| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 6] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 6] | | ------------------ ------------------ 754| 1| return status; 755| 6| status = _csi_ostack_get_number (ctx, 2, &g); 756| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 757| 1| return status; 758| 5| status = _csi_ostack_get_number (ctx, 3, &r); 759| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5] | | ------------------ ------------------ 760| 0| return status; 761| 5| status = _csi_ostack_get_number (ctx, 4, &offset); 762| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5] | | ------------------ ------------------ 763| 0| return status; 764| 5| status = _csi_ostack_get_pattern (ctx, 5, &pattern); 765| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 766| 5| return status; 767| | 768| 0| cairo_pattern_add_color_stop_rgba (pattern, offset, r, g, b, a); 769| | 770| 0| pop (5); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 771| 0| return CSI_STATUS_SUCCESS; 772| 5|} cairo-script-operators.c:_csi_ostack_get_pattern: 348| 50|{ 349| 50| csi_object_t *obj; 350| | 351| 50| obj = _csi_peek_ostack (ctx, i); 352| 50| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_PATTERN)) ------------------ | | 120| 50|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 50| __extension__ ({ \ | | | | 112| 50| int _csi_boolean_var_; \ | | | | 113| 50| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 39, False: 11] | | | | ------------------ | | | | 114| 50| _csi_boolean_var_ = 1; \ | | | | 115| 50| else \ | | | | 116| 50| _csi_boolean_var_ = 0; \ | | | | 117| 50| _csi_boolean_var_; \ | | | | 118| 50|}) | | ------------------ | | | Branch (120:29): [True: 39, False: 11] | | ------------------ ------------------ 353| 39| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 354| | 355| 11| *out = obj->datum.pattern; 356| 11| return CSI_STATUS_SUCCESS; 357| 50|} cairo-script-operators.c:_and: 776| 302|{ 777| 302| csi_object_t *a, *b; 778| 302| int type; 779| | 780| 302| check (2); ------------------ | | 93| 302|#define check(CNT) do {\ | | 94| 302| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 302|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 302| __extension__ ({ \ | | | | | | 112| 302| int _csi_boolean_var_; \ | | | | | | 113| 302| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 300] | | | | | | ------------------ | | | | | | 114| 302| _csi_boolean_var_ = 1; \ | | | | | | 115| 302| else \ | | | | | | 116| 302| _csi_boolean_var_ = 0; \ | | | | | | 117| 302| _csi_boolean_var_; \ | | | | | | 118| 302|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 300] | | | | ------------------ | | ------------------ | | 95| 302| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 302|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 300] | | ------------------ ------------------ 781| | 782| 300| a = _csi_peek_ostack (ctx, 0); 783| 300| b = _csi_peek_ostack (ctx, 1); 784| 300| if (_csi_unlikely (csi_object_get_type (a) != csi_object_get_type (b))) ------------------ | | 120| 300|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 300| __extension__ ({ \ | | | | 112| 300| int _csi_boolean_var_; \ | | | | 113| 300| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 298] | | | | ------------------ | | | | 114| 300| _csi_boolean_var_ = 1; \ | | | | 115| 300| else \ | | | | 116| 300| _csi_boolean_var_ = 0; \ | | | | 117| 300| _csi_boolean_var_; \ | | | | 118| 300|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 298] | | ------------------ ------------------ 785| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 786| | 787| 298| pop (2); ------------------ | | 97| 298|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 788| 298| type = csi_object_get_type (a); 789| 298| switch (type) { 790| 2| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (790:5): [True: 2, False: 296] ------------------ 791| 2| return _csi_push_ostack_integer (ctx, 792| 2| a->datum.integer & b->datum.integer); 793| 295| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (793:5): [True: 295, False: 3] ------------------ 794| 295| return _csi_push_ostack_boolean (ctx, 795| 295| a->datum.boolean & b->datum.boolean); 796| 1| default: ------------------ | Branch (796:5): [True: 1, False: 297] ------------------ 797| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 798| 298| } 799| 298|} cairo-script-operators.c:_arc: 803| 13|{ 804| 13| csi_status_t status; 805| 13| double x, y, r; 806| 13| double theta1, theta2; 807| 13| cairo_t *cr; 808| | 809| 13| check (6); ------------------ | | 93| 13|#define check(CNT) do {\ | | 94| 13| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 13|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 13| __extension__ ({ \ | | | | | | 112| 13| int _csi_boolean_var_; \ | | | | | | 113| 13| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 12] | | | | | | ------------------ | | | | | | 114| 13| _csi_boolean_var_ = 1; \ | | | | | | 115| 13| else \ | | | | | | 116| 13| _csi_boolean_var_ = 0; \ | | | | | | 117| 13| _csi_boolean_var_; \ | | | | | | 118| 13|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 12] | | | | ------------------ | | ------------------ | | 95| 13| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 13|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 12] | | ------------------ ------------------ 810| | 811| 12| status = _csi_ostack_get_number (ctx, 0, &theta2); 812| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 9] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 9] | | ------------------ ------------------ 813| 3| return status; 814| 9| status = _csi_ostack_get_number (ctx, 1, &theta1); 815| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 8] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 8] | | ------------------ ------------------ 816| 1| return status; 817| 8| status = _csi_ostack_get_number (ctx, 2, &r); 818| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 7] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 7] | | ------------------ ------------------ 819| 1| return status; 820| 7| status = _csi_ostack_get_number (ctx, 3, &y); 821| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 822| 2| return status; 823| 5| status = _csi_ostack_get_number (ctx, 4, &x); 824| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 3] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 3] | | ------------------ ------------------ 825| 2| return status; 826| 3| status = _csi_ostack_get_context (ctx, 5, &cr); 827| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 828| 3| return status; 829| | 830| | /* XXX handle path object */ 831| | 832| 0| cairo_arc (cr, x, y, r, theta1, theta2); 833| 0| pop (5); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 834| 0| return CSI_STATUS_SUCCESS; 835| 3|} cairo-script-operators.c:_csi_ostack_get_context: 322| 186|{ 323| 186| csi_object_t *obj; 324| | 325| 186| obj = _csi_peek_ostack (ctx, i); 326| 186| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_CONTEXT)) ------------------ | | 120| 186|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 186| __extension__ ({ \ | | | | 112| 186| int _csi_boolean_var_; \ | | | | 113| 186| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 186, False: 0] | | | | ------------------ | | | | 114| 186| _csi_boolean_var_ = 1; \ | | | | 115| 186| else \ | | | | 116| 186| _csi_boolean_var_ = 0; \ | | | | 117| 186| _csi_boolean_var_; \ | | | | 118| 186|}) | | ------------------ | | | Branch (120:29): [True: 186, False: 0] | | ------------------ ------------------ 327| 186| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 328| | 329| 0| *out = obj->datum.cr; 330| 0| return CSI_STATUS_SUCCESS; 331| 186|} cairo-script-operators.c:_arc_negative: 839| 14|{ 840| 14| csi_status_t status; 841| 14| double x, y, r; 842| 14| double theta1, theta2; 843| 14| cairo_t *cr; 844| | 845| 14| check (6); ------------------ | | 93| 14|#define check(CNT) do {\ | | 94| 14| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 14| __extension__ ({ \ | | | | | | 112| 14| int _csi_boolean_var_; \ | | | | | | 113| 14| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 11] | | | | | | ------------------ | | | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | | | 115| 14| else \ | | | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | | | 117| 14| _csi_boolean_var_; \ | | | | | | 118| 14|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 11] | | | | ------------------ | | ------------------ | | 95| 14| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 14|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 11] | | ------------------ ------------------ 846| | 847| 11| status = _csi_ostack_get_number (ctx, 0, &theta2); 848| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 9] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 9] | | ------------------ ------------------ 849| 2| return status; 850| 9| status = _csi_ostack_get_number (ctx, 1, &theta1); 851| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 8] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 8] | | ------------------ ------------------ 852| 1| return status; 853| 8| status = _csi_ostack_get_number (ctx, 2, &r); 854| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 7] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 7] | | ------------------ ------------------ 855| 1| return status; 856| 7| status = _csi_ostack_get_number (ctx, 3, &y); 857| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 858| 2| return status; 859| 5| status = _csi_ostack_get_number (ctx, 4, &x); 860| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 3] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 3] | | ------------------ ------------------ 861| 2| return status; 862| 3| status = _csi_ostack_get_context (ctx, 5, &cr); 863| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 864| 3| return status; 865| | 866| | /* XXX handle path object */ 867| | 868| 0| cairo_arc_negative (cr, x, y, r, theta1, theta2); 869| 0| pop (5); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 870| 0| return CSI_STATUS_SUCCESS; 871| 3|} cairo-script-operators.c:_array: 875| 1.65k|{ 876| 1.65k| csi_object_t obj; 877| 1.65k| csi_status_t status; 878| | 879| 1.65k| status = csi_array_new (ctx, 0, &obj); 880| 1.65k| if (_csi_unlikely (status)) ------------------ | | 120| 1.65k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.65k| __extension__ ({ \ | | | | 112| 1.65k| int _csi_boolean_var_; \ | | | | 113| 1.65k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.65k] | | | | ------------------ | | | | 114| 1.65k| _csi_boolean_var_ = 1; \ | | | | 115| 1.65k| else \ | | | | 116| 1.65k| _csi_boolean_var_ = 0; \ | | | | 117| 1.65k| _csi_boolean_var_; \ | | | | 118| 1.65k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.65k] | | ------------------ ------------------ 881| 0| return status; 882| | 883| 1.65k| return push (&obj); ------------------ | | 98| 1.65k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 884| 1.65k|} cairo-script-operators.c:_bind: 947| 3|{ 948| 3| csi_array_t *array; 949| 3| csi_status_t status; 950| | 951| 3| check (1); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 952| | 953| 2| status = _csi_ostack_get_procedure (ctx, 0, &array); 954| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 955| 2| return status; 956| | 957| 0| status = _bind_substitute (ctx, array); 958| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 959| 0| return status; 960| | 961| 0| status = _idiom_substitute (ctx, array); 962| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 963| 0| return status; 964| | 965| 0| return CSI_STATUS_SUCCESS; 966| 0|} cairo-script-operators.c:_csi_ostack_get_procedure: 412| 14|{ 413| 14| csi_object_t *obj; 414| | 415| 14| obj = _csi_peek_ostack (ctx, i); 416| 14| if (_csi_unlikely (! csi_object_is_procedure (obj))) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 13, False: 1] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 13, False: 1] | | ------------------ ------------------ 417| 13| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 418| | 419| 1| *out = obj->datum.array; 420| 1| return CSI_STATUS_SUCCESS; 421| 14|} cairo-script-operators.c:_bitshift: 970| 208|{ 971| 208| long v, shift; 972| 208| csi_status_t status; 973| | 974| 208| check (2); ------------------ | | 93| 208|#define check(CNT) do {\ | | 94| 208| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 208|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 208| __extension__ ({ \ | | | | | | 112| 208| int _csi_boolean_var_; \ | | | | | | 113| 208| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 207] | | | | | | ------------------ | | | | | | 114| 208| _csi_boolean_var_ = 1; \ | | | | | | 115| 208| else \ | | | | | | 116| 208| _csi_boolean_var_ = 0; \ | | | | | | 117| 208| _csi_boolean_var_; \ | | | | | | 118| 208|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 207] | | | | ------------------ | | ------------------ | | 95| 208| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 208|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 207] | | ------------------ ------------------ 975| | 976| 207| status = _csi_ostack_get_integer (ctx, 0, &shift); 977| 207| if (_csi_unlikely (status)) ------------------ | | 120| 207|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 207| __extension__ ({ \ | | | | 112| 207| int _csi_boolean_var_; \ | | | | 113| 207| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 205] | | | | ------------------ | | | | 114| 207| _csi_boolean_var_ = 1; \ | | | | 115| 207| else \ | | | | 116| 207| _csi_boolean_var_ = 0; \ | | | | 117| 207| _csi_boolean_var_; \ | | | | 118| 207|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 205] | | ------------------ ------------------ 978| 2| return status; 979| 205| status = _csi_ostack_get_integer (ctx, 1, &v); 980| 205| if (_csi_unlikely (status)) ------------------ | | 120| 205|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 205| __extension__ ({ \ | | | | 112| 205| int _csi_boolean_var_; \ | | | | 113| 205| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 204] | | | | ------------------ | | | | 114| 205| _csi_boolean_var_ = 1; \ | | | | 115| 205| else \ | | | | 116| 205| _csi_boolean_var_ = 0; \ | | | | 117| 205| _csi_boolean_var_; \ | | | | 118| 205|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 204] | | ------------------ ------------------ 981| 1| return status; 982| | 983| 204| if (shift < 0) { ------------------ | Branch (983:9): [True: 7, False: 197] ------------------ 984| 7| shift = -shift; 985| 7| v >>= shift; 986| 7| } else 987| 197| v <<= shift; 988| | 989| 204| pop (1); ------------------ | | 97| 204|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 990| 204| _csi_peek_ostack (ctx, 0)->datum.integer = v; 991| | 992| 204| return CSI_STATUS_SUCCESS; 993| 205|} cairo-script-operators.c:_csi_ostack_get_integer: 243| 9.30k|{ 244| 9.30k| csi_object_t *obj; 245| 9.30k| int type; 246| | 247| 9.30k| obj = _csi_peek_ostack (ctx, i); 248| 9.30k| type = csi_object_get_type (obj); 249| 9.30k| switch (type) { 250| 949| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (250:5): [True: 949, False: 8.35k] ------------------ 251| 949| *out = obj->datum.boolean; 252| 949| break; 253| 7.33k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (253:5): [True: 7.33k, False: 1.97k] ------------------ 254| 7.33k| *out = obj->datum.integer; 255| 7.33k| break; 256| 981| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (256:5): [True: 981, False: 8.32k] ------------------ 257| 981| *out = obj->datum.real; 258| 981| break; 259| 42| default: ------------------ | Branch (259:5): [True: 42, False: 9.26k] ------------------ 260| 42| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 261| 9.30k| } 262| 9.26k| return CSI_STATUS_SUCCESS; 263| 9.30k|} cairo-script-operators.c:_curve_to: 1126| 10.0k|{ 1127| 10.0k| csi_status_t status; 1128| 10.0k| csi_object_t *obj; 1129| 10.0k| int type; 1130| 10.0k| double x1, y1; 1131| 10.0k| double x2, y2; 1132| 10.0k| double x3, y3; 1133| | 1134| 10.0k| check (7); ------------------ | | 93| 10.0k|#define check(CNT) do {\ | | 94| 10.0k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10.0k| __extension__ ({ \ | | | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | | | 113| 10.0k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 5, False: 10.0k] | | | | | | ------------------ | | | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | | | 115| 10.0k| else \ | | | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | | | 118| 10.0k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 5, False: 10.0k] | | | | ------------------ | | ------------------ | | 95| 10.0k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10.0k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 10.0k] | | ------------------ ------------------ 1135| | 1136| 10.0k| status = _csi_ostack_get_number (ctx, 0, &y3); 1137| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1138| 1| return status; 1139| 10.0k| status = _csi_ostack_get_number (ctx, 1, &x3); 1140| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1141| 1| return status; 1142| 10.0k| status = _csi_ostack_get_number (ctx, 2, &y2); 1143| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1144| 1| return status; 1145| 10.0k| status = _csi_ostack_get_number (ctx, 3, &x2); 1146| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1147| 1| return status; 1148| 10.0k| status = _csi_ostack_get_number (ctx, 4, &y1); 1149| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1150| 1| return status; 1151| 10.0k| status = _csi_ostack_get_number (ctx, 5, &x1); 1152| 10.0k| if (_csi_unlikely (status)) ------------------ | | 120| 10.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.0k| __extension__ ({ \ | | | | 112| 10.0k| int _csi_boolean_var_; \ | | | | 113| 10.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10.0k] | | | | ------------------ | | | | 114| 10.0k| _csi_boolean_var_ = 1; \ | | | | 115| 10.0k| else \ | | | | 116| 10.0k| _csi_boolean_var_ = 0; \ | | | | 117| 10.0k| _csi_boolean_var_; \ | | | | 118| 10.0k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10.0k] | | ------------------ ------------------ 1153| 1| return status; 1154| | 1155| 10.0k| obj = _csi_peek_ostack (ctx, 6); 1156| 10.0k| type = csi_object_get_type (obj); 1157| 10.0k| switch (type) { ------------------ | Branch (1157:13): [True: 1, False: 10.0k] ------------------ 1158| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (1158:5): [True: 0, False: 10.0k] ------------------ 1159| 0| cairo_curve_to (obj->datum.cr, x1, y1, x2, y2, x3, y3); 1160| 0| break; 1161| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (1161:5): [True: 1, False: 10.0k] ------------------ 1162| 1| cairo_mesh_pattern_curve_to (obj->datum.pattern, 1163| 1| x1, y1, x2, y2, x3, y3); 1164| 1| break; 1165| | /* XXX handle path object */ 1166| 10.0k| } 1167| | 1168| 10.0k| pop (6); ------------------ | | 97| 10.0k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1169| 10.0k| return CSI_STATUS_SUCCESS; 1170| 10.0k|} cairo-script-operators.c:_rel_curve_to: 4243| 21|{ 4244| 21| csi_status_t status; 4245| 21| double x1, y1; 4246| 21| double x2, y2; 4247| 21| double x3, y3; 4248| 21| cairo_t *cr; 4249| | 4250| 21| check (7); ------------------ | | 93| 21|#define check(CNT) do {\ | | 94| 21| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 21|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 21| __extension__ ({ \ | | | | | | 112| 21| int _csi_boolean_var_; \ | | | | | | 113| 21| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 19] | | | | | | ------------------ | | | | | | 114| 21| _csi_boolean_var_ = 1; \ | | | | | | 115| 21| else \ | | | | | | 116| 21| _csi_boolean_var_ = 0; \ | | | | | | 117| 21| _csi_boolean_var_; \ | | | | | | 118| 21|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 19] | | | | ------------------ | | ------------------ | | 95| 21| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 21|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 19] | | ------------------ ------------------ 4251| | 4252| 19| status = _csi_ostack_get_number (ctx, 0, &y3); 4253| 19| if (_csi_unlikely (status)) ------------------ | | 120| 19|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 19| __extension__ ({ \ | | | | 112| 19| int _csi_boolean_var_; \ | | | | 113| 19| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 17] | | | | ------------------ | | | | 114| 19| _csi_boolean_var_ = 1; \ | | | | 115| 19| else \ | | | | 116| 19| _csi_boolean_var_ = 0; \ | | | | 117| 19| _csi_boolean_var_; \ | | | | 118| 19|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 17] | | ------------------ ------------------ 4254| 2| return status; 4255| 17| status = _csi_ostack_get_number (ctx, 1, &x3); 4256| 17| if (_csi_unlikely (status)) ------------------ | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 17| __extension__ ({ \ | | | | 112| 17| int _csi_boolean_var_; \ | | | | 113| 17| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 16] | | | | ------------------ | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | 115| 17| else \ | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | 117| 17| _csi_boolean_var_; \ | | | | 118| 17|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 16] | | ------------------ ------------------ 4257| 1| return status; 4258| 16| status = _csi_ostack_get_number (ctx, 2, &y2); 4259| 16| if (_csi_unlikely (status)) ------------------ | | 120| 16|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 16| __extension__ ({ \ | | | | 112| 16| int _csi_boolean_var_; \ | | | | 113| 16| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 15] | | | | ------------------ | | | | 114| 16| _csi_boolean_var_ = 1; \ | | | | 115| 16| else \ | | | | 116| 16| _csi_boolean_var_ = 0; \ | | | | 117| 16| _csi_boolean_var_; \ | | | | 118| 16|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 15] | | ------------------ ------------------ 4260| 1| return status; 4261| 15| status = _csi_ostack_get_number (ctx, 3, &x2); 4262| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 14] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 14] | | ------------------ ------------------ 4263| 1| return status; 4264| 14| status = _csi_ostack_get_number (ctx, 4, &y1); 4265| 14| if (_csi_unlikely (status)) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 12] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 12] | | ------------------ ------------------ 4266| 2| return status; 4267| 12| status = _csi_ostack_get_number (ctx, 5, &x1); 4268| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 11] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 11] | | ------------------ ------------------ 4269| 1| return status; 4270| 11| status = _csi_ostack_get_context (ctx, 6, &cr); 4271| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 11, False: 0] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 11, False: 0] | | ------------------ ------------------ 4272| 11| return status; 4273| | 4274| | /* XXX path object */ 4275| | 4276| 0| cairo_rel_curve_to (cr, x1, y1, x2, y2, x3, y3); 4277| 0| pop (6); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4278| 0| return CSI_STATUS_SUCCESS; 4279| 11|} cairo-script-operators.c:_clip: 997| 7|{ 998| 7| return _do_cairo_op (ctx, cairo_clip); 999| 7|} cairo-script-operators.c:_do_cairo_op: 569| 75|{ 570| 75| cairo_t *cr; 571| 75| csi_status_t status; 572| | 573| 75| check (1); ------------------ | | 93| 75|#define check(CNT) do {\ | | 94| 75| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 75|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 75| __extension__ ({ \ | | | | | | 112| 75| int _csi_boolean_var_; \ | | | | | | 113| 75| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 13, False: 62] | | | | | | ------------------ | | | | | | 114| 75| _csi_boolean_var_ = 1; \ | | | | | | 115| 75| else \ | | | | | | 116| 75| _csi_boolean_var_ = 0; \ | | | | | | 117| 75| _csi_boolean_var_; \ | | | | | | 118| 75|}) | | | | ------------------ | | | | | Branch (120:29): [True: 13, False: 62] | | | | ------------------ | | ------------------ | | 95| 75| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 75|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 62] | | ------------------ ------------------ 574| | 575| 62| status = _csi_ostack_get_context (ctx, 0, &cr); 576| 62| if (_csi_unlikely (status)) ------------------ | | 120| 62|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 62| __extension__ ({ \ | | | | 112| 62| int _csi_boolean_var_; \ | | | | 113| 62| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 62, False: 0] | | | | ------------------ | | | | 114| 62| _csi_boolean_var_ = 1; \ | | | | 115| 62| else \ | | | | 116| 62| _csi_boolean_var_ = 0; \ | | | | 117| 62| _csi_boolean_var_; \ | | | | 118| 62|}) | | ------------------ | | | Branch (120:29): [True: 62, False: 0] | | ------------------ ------------------ 577| 62| return status; 578| | 579| 0| op (cr); 580| 0| return CSI_STATUS_SUCCESS; 581| 62|} cairo-script-operators.c:_clip_preserve: 1003| 4|{ 1004| 4| return _do_cairo_op (ctx, cairo_clip_preserve); 1005| 4|} cairo-script-operators.c:_close_path: 1009| 3|{ 1010| 3| return _do_cairo_op (ctx, cairo_close_path); 1011| 3|} cairo-script-operators.c:_context: 1015| 2|{ 1016| 2| csi_object_t obj; 1017| 2| csi_status_t status; 1018| 2| cairo_surface_t *surface; 1019| 2| cairo_t *cr; 1020| 2| csi_context_create_func_t hook; 1021| 2| csi_proxy_t *proxy; 1022| | 1023| 2| check (1); ------------------ | | 93| 2|#define check(CNT) do {\ | | 94| 2| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2| __extension__ ({ \ | | | | | | 112| 2| int _csi_boolean_var_; \ | | | | | | 113| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 1] | | | | | | ------------------ | | | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | | | 115| 2| else \ | | | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | | | 117| 2| _csi_boolean_var_; \ | | | | | | 118| 2|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 1] | | | | ------------------ | | ------------------ | | 95| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1] | | ------------------ ------------------ 1024| | 1025| 1| status = _csi_ostack_get_surface (ctx, 0, &surface); 1026| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 1027| 1| return status; 1028| | 1029| 0| hook = ctx->hooks.context_create; 1030| 0| if (hook != NULL) ------------------ | Branch (1030:9): [True: 0, False: 0] ------------------ 1031| 0| cr = hook (ctx->hooks.closure, surface); 1032| 0| else 1033| 0| cr = cairo_create (surface); 1034| | 1035| 0| proxy = _csi_proxy_create (ctx, cr, NULL, 1036| 0| ctx->hooks.context_destroy, 1037| 0| ctx->hooks.closure); 1038| 0| if (_csi_unlikely (proxy == NULL)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 1039| 0| cairo_destroy (cr); 1040| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 1041| 0| } 1042| | 1043| 0| status = cairo_set_user_data (cr, &_csi_proxy_key, 1044| 0| proxy, _csi_proxy_destroy); 1045| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 1046| 0| _csi_proxy_destroy (proxy); 1047| 0| cairo_destroy (cr); 1048| 0| return status; 1049| 0| } 1050| | 1051| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1052| 0| obj.type = CSI_OBJECT_TYPE_CONTEXT; 1053| 0| obj.datum.cr = cr; 1054| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 1055| 0|} cairo-script-operators.c:_csi_ostack_get_surface: 378| 54|{ 379| 54| csi_object_t *obj; 380| 54| int type; 381| | 382| 54| obj = _csi_peek_ostack (ctx, i); 383| 54| type = csi_object_get_type (obj); 384| 54| switch (type) { 385| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (385:5): [True: 0, False: 54] ------------------ 386| 0| *out = cairo_get_target (obj->datum.cr); 387| 0| break; 388| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (388:5): [True: 0, False: 54] ------------------ 389| 0| *out = obj->datum.surface; 390| 0| break; 391| 54| default: ------------------ | Branch (391:5): [True: 54, False: 0] ------------------ 392| 54| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 393| 54| } 394| 0| return CSI_STATUS_SUCCESS; 395| 54|} cairo-script-operators.c:_copy: 1059| 66|{ 1060| 66| csi_object_t *obj; 1061| 66| int type; 1062| | 1063| 66| check (1); ------------------ | | 93| 66|#define check(CNT) do {\ | | 94| 66| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 66|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 66| __extension__ ({ \ | | | | | | 112| 66| int _csi_boolean_var_; \ | | | | | | 113| 66| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 65] | | | | | | ------------------ | | | | | | 114| 66| _csi_boolean_var_ = 1; \ | | | | | | 115| 66| else \ | | | | | | 116| 66| _csi_boolean_var_ = 0; \ | | | | | | 117| 66| _csi_boolean_var_; \ | | | | | | 118| 66|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 65] | | | | ------------------ | | ------------------ | | 95| 66| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 66|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 65] | | ------------------ ------------------ 1064| | 1065| 65| obj = csi_object_reference (_csi_peek_ostack (ctx, 0)); 1066| 65| pop (1); ------------------ | | 97| 65|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1067| | 1068| 65| type = csi_object_get_type (obj); 1069| 65| switch (type) { 1070| | /*XXX array, string, dictionary, etc */ 1071| 63| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (1071:5): [True: 63, False: 2] ------------------ 1072| 63| { 1073| 63| long i, n; 1074| | 1075| 63| n = obj->datum.integer; 1076| 63| if (_csi_unlikely (n < 0)) ------------------ | | 120| 63|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 63| __extension__ ({ \ | | | | 112| 63| int _csi_boolean_var_; \ | | | | 113| 63| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 56] | | | | ------------------ | | | | 114| 63| _csi_boolean_var_ = 1; \ | | | | 115| 63| else \ | | | | 116| 63| _csi_boolean_var_ = 0; \ | | | | 117| 63| _csi_boolean_var_; \ | | | | 118| 63|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 56] | | ------------------ ------------------ 1077| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1078| 56| check (n); ------------------ | | 93| 56|#define check(CNT) do {\ | | 94| 56| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 56|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 56| __extension__ ({ \ | | | | | | 112| 56| int _csi_boolean_var_; \ | | | | | | 113| 56| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 17, False: 39] | | | | | | ------------------ | | | | | | 114| 56| _csi_boolean_var_ = 1; \ | | | | | | 115| 56| else \ | | | | | | 116| 56| _csi_boolean_var_ = 0; \ | | | | | | 117| 56| _csi_boolean_var_; \ | | | | | | 118| 56|}) | | | | ------------------ | | | | | Branch (120:29): [True: 17, False: 39] | | | | ------------------ | | ------------------ | | 95| 56| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 56|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 39] | | ------------------ ------------------ 1079| | 1080| 64| for (i = n; i--; ) { ------------------ | Branch (1080:18): [True: 25, False: 39] ------------------ 1081| 25| csi_status_t status; 1082| | 1083| 25| status = _csi_push_ostack_copy (ctx, 1084| 25| _csi_peek_ostack (ctx, n-1)); 1085| 25| if (_csi_unlikely (status)) ------------------ | | 120| 25|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 25| __extension__ ({ \ | | | | 112| 25| int _csi_boolean_var_; \ | | | | 113| 25| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 25] | | | | ------------------ | | | | 114| 25| _csi_boolean_var_ = 1; \ | | | | 115| 25| else \ | | | | 116| 25| _csi_boolean_var_ = 0; \ | | | | 117| 25| _csi_boolean_var_; \ | | | | 118| 25|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 25] | | ------------------ ------------------ 1086| 0| return status; 1087| 25| } 1088| 39| break; 1089| 39| } 1090| 39| default: ------------------ | Branch (1090:5): [True: 2, False: 63] ------------------ 1091| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1092| 65| } 1093| | 1094| 39| return CSI_STATUS_SUCCESS; 1095| 65|} cairo-script-operators.c:_copy_page: 1099| 3|{ 1100| 3| csi_object_t *obj; 1101| 3| int type; 1102| | 1103| 3| check (1); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 1104| | 1105| 2| obj = _csi_peek_ostack (ctx, 0); 1106| 2| type = csi_object_get_type (obj); 1107| 2| switch (type) { 1108| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (1108:5): [True: 0, False: 2] ------------------ 1109| 0| cairo_copy_page (obj->datum.cr); 1110| 0| if (ctx->hooks.copy_page != NULL) ------------------ | Branch (1110:6): [True: 0, False: 0] ------------------ 1111| 0| ctx->hooks.copy_page (ctx->hooks.closure, obj->datum.cr); 1112| 0| break; 1113| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (1113:5): [True: 0, False: 2] ------------------ 1114| 0| cairo_surface_copy_page (obj->datum.surface); 1115| | /* XXX hook? */ 1116| 0| break; 1117| 2| default: ------------------ | Branch (1117:5): [True: 2, False: 0] ------------------ 1118| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1119| 2| } 1120| | 1121| 0| return CSI_STATUS_SUCCESS; 1122| 2|} cairo-script-operators.c:_cvi: 1174| 229|{ 1175| 229| csi_object_t *val, obj; 1176| 229| int type; 1177| | 1178| 229| check (1); ------------------ | | 93| 229|#define check(CNT) do {\ | | 94| 229| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 229|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 229| __extension__ ({ \ | | | | | | 112| 229| int _csi_boolean_var_; \ | | | | | | 113| 229| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 228] | | | | | | ------------------ | | | | | | 114| 229| _csi_boolean_var_ = 1; \ | | | | | | 115| 229| else \ | | | | | | 116| 229| _csi_boolean_var_ = 0; \ | | | | | | 117| 229| _csi_boolean_var_; \ | | | | | | 118| 229|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 228] | | | | ------------------ | | ------------------ | | 95| 229| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 229|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 228] | | ------------------ ------------------ 1179| | 1180| 228| val = _csi_peek_ostack (ctx, 0); 1181| 228| type = csi_object_get_type (val); 1182| 228| switch (type) { 1183| 134| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (1183:5): [True: 134, False: 94] ------------------ 1184| 134| return CSI_STATUS_SUCCESS; 1185| | 1186| 90| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (1186:5): [True: 90, False: 138] ------------------ 1187| 90| pop (1); ------------------ | | 97| 90|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1188| 90| return _csi_push_ostack_integer (ctx, val->datum.real); 1189| | 1190| 1| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (1190:5): [True: 1, False: 227] ------------------ 1191| 1| if (! _csi_parse_number (&obj, ------------------ | Branch (1191:6): [True: 1, False: 0] ------------------ 1192| 1| val->datum.string->string, 1193| 1| val->datum.string->len)) 1194| 1| { 1195| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1196| 1| } 1197| | 1198| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1199| 0| if (csi_object_get_type (&obj) == CSI_OBJECT_TYPE_INTEGER) ------------------ | Branch (1199:6): [True: 0, False: 0] ------------------ 1200| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 1201| 0| else 1202| 0| return _csi_push_ostack_integer (ctx, obj.datum.real); 1203| | 1204| 3| default: ------------------ | Branch (1204:5): [True: 3, False: 225] ------------------ 1205| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1206| 228| } 1207| 228|} cairo-script-operators.c:_cvr: 1211| 1.37k|{ 1212| 1.37k| csi_object_t *val, obj; 1213| 1.37k| int type; 1214| | 1215| 1.37k| check (1); ------------------ | | 93| 1.37k|#define check(CNT) do {\ | | 94| 1.37k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 1.37k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 1.37k| __extension__ ({ \ | | | | | | 112| 1.37k| int _csi_boolean_var_; \ | | | | | | 113| 1.37k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 1.37k] | | | | | | ------------------ | | | | | | 114| 1.37k| _csi_boolean_var_ = 1; \ | | | | | | 115| 1.37k| else \ | | | | | | 116| 1.37k| _csi_boolean_var_ = 0; \ | | | | | | 117| 1.37k| _csi_boolean_var_; \ | | | | | | 118| 1.37k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 1.37k] | | | | ------------------ | | ------------------ | | 95| 1.37k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 1.37k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.37k] | | ------------------ ------------------ 1216| | 1217| 1.37k| val = _csi_peek_ostack (ctx, 0); 1218| 1.37k| type = csi_object_get_type (val); 1219| 1.37k| switch (type) { 1220| 534| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (1220:5): [True: 534, False: 836] ------------------ 1221| 534| return CSI_STATUS_SUCCESS; 1222| | 1223| 834| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (1223:5): [True: 834, False: 536] ------------------ 1224| 834| pop (1); ------------------ | | 97| 834|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1225| 834| return _csi_push_ostack_real (ctx, val->datum.integer); 1226| | 1227| 1| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (1227:5): [True: 1, False: 1.36k] ------------------ 1228| 1| if (! _csi_parse_number (&obj, ------------------ | Branch (1228:6): [True: 1, False: 0] ------------------ 1229| 1| val->datum.string->string, 1230| 1| val->datum.string->len)) 1231| 1| { 1232| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1233| 1| } 1234| | 1235| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1236| 0| if (csi_object_get_type (&obj) == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (1236:6): [True: 0, False: 0] ------------------ 1237| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 1238| 0| else 1239| 0| return _csi_push_ostack_real (ctx, obj.datum.integer); 1240| | 1241| 1| default: ------------------ | Branch (1241:5): [True: 1, False: 1.36k] ------------------ 1242| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1243| 1.37k| } 1244| 1.37k|} cairo-script-operators.c:_def: 1248| 65|{ 1249| 65| csi_name_t name = 0; /* silence the compiler */ 1250| 65| csi_status_t status; 1251| | 1252| 65| check (2); ------------------ | | 93| 65|#define check(CNT) do {\ | | 94| 65| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 65|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 65| __extension__ ({ \ | | | | | | 112| 65| int _csi_boolean_var_; \ | | | | | | 113| 65| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 62] | | | | | | ------------------ | | | | | | 114| 65| _csi_boolean_var_ = 1; \ | | | | | | 115| 65| else \ | | | | | | 116| 65| _csi_boolean_var_ = 0; \ | | | | | | 117| 65| _csi_boolean_var_; \ | | | | | | 118| 65|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 62] | | | | ------------------ | | ------------------ | | 95| 65| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 65|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 62] | | ------------------ ------------------ 1253| | 1254| 62| status = _csi_ostack_get_name (ctx, 1, &name); 1255| 62| if (_csi_unlikely (status)) ------------------ | | 120| 62|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 62| __extension__ ({ \ | | | | 112| 62| int _csi_boolean_var_; \ | | | | 113| 62| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 55] | | | | ------------------ | | | | 114| 62| _csi_boolean_var_ = 1; \ | | | | 115| 62| else \ | | | | 116| 62| _csi_boolean_var_ = 0; \ | | | | 117| 62| _csi_boolean_var_; \ | | | | 118| 62|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 55] | | ------------------ ------------------ 1256| 7| return status; 1257| | 1258| 55| status = _csi_name_define (ctx, name, _csi_peek_ostack (ctx, 0)); 1259| 55| if (_csi_unlikely (status)) ------------------ | | 120| 55|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 55| __extension__ ({ \ | | | | 112| 55| int _csi_boolean_var_; \ | | | | 113| 55| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 55] | | | | ------------------ | | | | 114| 55| _csi_boolean_var_ = 1; \ | | | | 115| 55| else \ | | | | 116| 55| _csi_boolean_var_ = 0; \ | | | | 117| 55| _csi_boolean_var_; \ | | | | 118| 55|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 55] | | ------------------ ------------------ 1260| 0| return status; 1261| | 1262| 55| pop (2); ------------------ | | 97| 55|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1263| 55| return CSI_STATUS_SUCCESS; 1264| 55|} cairo-script-operators.c:_csi_ostack_get_name: 309| 76|{ 310| 76| csi_object_t *obj; 311| | 312| 76| obj = _csi_peek_ostack (ctx, i); 313| 76| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 76|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 76| __extension__ ({ \ | | | | 112| 76| int _csi_boolean_var_; \ | | | | 113| 76| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 19, False: 57] | | | | ------------------ | | | | 114| 76| _csi_boolean_var_ = 1; \ | | | | 115| 76| else \ | | | | 116| 76| _csi_boolean_var_ = 0; \ | | | | 117| 76| _csi_boolean_var_; \ | | | | 118| 76|}) | | ------------------ | | | Branch (120:29): [True: 19, False: 57] | | ------------------ ------------------ 314| 19| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 315| | 316| 57| *out = obj->datum.name; 317| 57| return CSI_STATUS_SUCCESS; 318| 76|} cairo-script-operators.c:_dict: 1268| 75.9k|{ 1269| 75.9k| csi_object_t obj; 1270| 75.9k| csi_status_t status; 1271| | 1272| 75.9k| status = csi_dictionary_new (ctx, &obj); 1273| 75.9k| if (_csi_unlikely (status)) ------------------ | | 120| 75.9k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 75.9k| __extension__ ({ \ | | | | 112| 75.9k| int _csi_boolean_var_; \ | | | | 113| 75.9k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 75.9k] | | | | ------------------ | | | | 114| 75.9k| _csi_boolean_var_ = 1; \ | | | | 115| 75.9k| else \ | | | | 116| 75.9k| _csi_boolean_var_ = 0; \ | | | | 117| 75.9k| _csi_boolean_var_; \ | | | | 118| 75.9k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 75.9k] | | ------------------ ------------------ 1274| 0| return status; 1275| | 1276| 75.9k| return push (&obj); ------------------ | | 98| 75.9k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 1277| 75.9k|} cairo-script-operators.c:_div: 1281| 2.97k|{ 1282| 2.97k| csi_object_t *A; 1283| 2.97k| csi_object_t *B; 1284| 2.97k| csi_object_type_t type_a, type_b; 1285| | 1286| 2.97k| check (2); ------------------ | | 93| 2.97k|#define check(CNT) do {\ | | 94| 2.97k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2.97k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2.97k| __extension__ ({ \ | | | | | | 112| 2.97k| int _csi_boolean_var_; \ | | | | | | 113| 2.97k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 2.97k] | | | | | | ------------------ | | | | | | 114| 2.97k| _csi_boolean_var_ = 1; \ | | | | | | 115| 2.97k| else \ | | | | | | 116| 2.97k| _csi_boolean_var_ = 0; \ | | | | | | 117| 2.97k| _csi_boolean_var_; \ | | | | | | 118| 2.97k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 2.97k] | | | | ------------------ | | ------------------ | | 95| 2.97k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2.97k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.97k] | | ------------------ ------------------ 1287| | 1288| 2.97k| B = _csi_peek_ostack (ctx, 0); 1289| 2.97k| A = _csi_peek_ostack (ctx, 1); 1290| | 1291| 2.97k| type_a = csi_object_get_type (A); 1292| 2.97k| if (_csi_unlikely (! (type_a == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 2.97k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.97k| __extension__ ({ \ | | | | 112| 2.97k| int _csi_boolean_var_; \ | | | | 113| 8.80k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 120, False: 2.85k] | | | | | Branch (113:8): [True: 2.84k, False: 7] | | | | ------------------ | | | | 114| 2.97k| _csi_boolean_var_ = 1; \ | | | | 115| 2.97k| else \ | | | | 116| 2.97k| _csi_boolean_var_ = 0; \ | | | | 117| 2.97k| _csi_boolean_var_; \ | | | | 118| 2.97k|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 2.96k] | | ------------------ ------------------ 1293| 2.97k| type_a == CSI_OBJECT_TYPE_REAL))) 1294| 7| { 1295| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1296| 7| } 1297| | 1298| 2.96k| type_b = csi_object_get_type (B); 1299| 2.96k| if (_csi_unlikely (! (type_b == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 2.96k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.96k| __extension__ ({ \ | | | | 112| 2.96k| int _csi_boolean_var_; \ | | | | 113| 8.78k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 122, False: 2.84k] | | | | | Branch (113:8): [True: 2.84k, False: 1] | | | | ------------------ | | | | 114| 2.96k| _csi_boolean_var_ = 1; \ | | | | 115| 2.96k| else \ | | | | 116| 2.96k| _csi_boolean_var_ = 0; \ | | | | 117| 2.96k| _csi_boolean_var_; \ | | | | 118| 2.96k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 2.96k] | | ------------------ ------------------ 1300| 2.96k| type_b == CSI_OBJECT_TYPE_REAL))) 1301| 1| { 1302| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1303| 1| } 1304| | 1305| 2.96k| pop (2); ------------------ | | 97| 2.96k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1306| | 1307| 2.96k| if (type_a == CSI_OBJECT_TYPE_REAL && ------------------ | Branch (1307:9): [True: 2.84k, False: 120] ------------------ 1308| 2.84k| type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (1308:2): [True: 2.84k, False: 3] ------------------ 1309| 2.84k| { 1310| 2.84k| return _csi_push_ostack_real (ctx, A->datum.real / B->datum.real); 1311| | 1312| 2.84k| } 1313| 123| else if (type_a == CSI_OBJECT_TYPE_INTEGER && ------------------ | Branch (1313:14): [True: 120, False: 3] ------------------ 1314| 120| type_b == CSI_OBJECT_TYPE_INTEGER) ------------------ | Branch (1314:7): [True: 119, False: 1] ------------------ 1315| 119| { 1316| 119| return _csi_push_ostack_integer (ctx, 1317| 119| A->datum.integer / B->datum.integer); 1318| 119| } 1319| 4| else 1320| 4| { 1321| 4| double v; 1322| | 1323| 4| if (type_a == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (1323:6): [True: 3, False: 1] ------------------ 1324| 3| v = A->datum.real; 1325| 1| else 1326| 1| v = A->datum.integer; 1327| | 1328| 4| if (type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (1328:6): [True: 1, False: 3] ------------------ 1329| 1| v /= B->datum.real; 1330| 3| else 1331| 3| v /= B->datum.integer; 1332| | 1333| 4| return _csi_push_ostack_real (ctx, v); 1334| 4| } 1335| 2.96k|} cairo-script-operators.c:_duplicate: 1339| 1.98k|{ 1340| 1.98k| check (1); ------------------ | | 93| 1.98k|#define check(CNT) do {\ | | 94| 1.98k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 1.98k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 1.98k| __extension__ ({ \ | | | | | | 112| 1.98k| int _csi_boolean_var_; \ | | | | | | 113| 1.98k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 1.98k] | | | | | | ------------------ | | | | | | 114| 1.98k| _csi_boolean_var_ = 1; \ | | | | | | 115| 1.98k| else \ | | | | | | 116| 1.98k| _csi_boolean_var_ = 0; \ | | | | | | 117| 1.98k| _csi_boolean_var_; \ | | | | | | 118| 1.98k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 1.98k] | | | | ------------------ | | ------------------ | | 95| 1.98k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 1.98k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.98k] | | ------------------ ------------------ 1341| | 1342| 1.98k| return _csi_push_ostack_copy (ctx, _csi_peek_ostack (ctx, 0)); 1343| 1.98k|} cairo-script-operators.c:_eq: 1347| 195k|{ 1348| 195k| csi_object_t *a, *b; 1349| 195k| csi_boolean_t v; 1350| | 1351| 195k| check (2); ------------------ | | 93| 195k|#define check(CNT) do {\ | | 94| 195k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 195k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 195k| __extension__ ({ \ | | | | | | 112| 195k| int _csi_boolean_var_; \ | | | | | | 113| 195k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 195k] | | | | | | ------------------ | | | | | | 114| 195k| _csi_boolean_var_ = 1; \ | | | | | | 115| 195k| else \ | | | | | | 116| 195k| _csi_boolean_var_ = 0; \ | | | | | | 117| 195k| _csi_boolean_var_; \ | | | | | | 118| 195k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 195k] | | | | ------------------ | | ------------------ | | 95| 195k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 195k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 195k] | | ------------------ ------------------ 1352| | 1353| 195k| b = _csi_peek_ostack (ctx, 0); 1354| 195k| a = _csi_peek_ostack (ctx, 1); 1355| | 1356| 195k| v = csi_object_eq (a, b); 1357| | 1358| 195k| pop (2); ------------------ | | 97| 195k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1359| 195k| return _csi_push_ostack_boolean (ctx, v); 1360| 195k|} cairo-script-operators.c:_exch: 1364| 8.76k|{ 1365| 8.76k| return _csi_stack_exch (&ctx->ostack); 1366| 8.76k|} cairo-script-operators.c:_false: 1370| 93.3k|{ 1371| 93.3k| return _csi_push_ostack_boolean (ctx, FALSE); ------------------ | | 51| 93.3k|#define FALSE 0 ------------------ 1372| 93.3k|} cairo-script-operators.c:_fill: 1376| 7|{ 1377| 7| return _do_cairo_op (ctx, cairo_fill); 1378| 7|} cairo-script-operators.c:_fill_preserve: 1382| 15|{ 1383| 15| return _do_cairo_op (ctx, cairo_fill_preserve); 1384| 15|} cairo-script-operators.c:_filter: 1388| 9|{ 1389| 9| csi_object_t *src; 1390| 9| csi_dictionary_t *dict = NULL; 1391| 9| csi_status_t status; 1392| 9| const char *name = NULL; /* silence the compiler */ 1393| 9| const struct filters { 1394| 9| const char *name; 1395| 9| csi_status_t (*constructor) (csi_t *t, 1396| 9| csi_object_t *, 1397| 9| csi_dictionary_t *, 1398| 9| csi_object_t *); 1399| 9| } filters[] = { 1400| 9| { "ascii85", csi_file_new_ascii85_decode }, 1401| 9|#if HAVE_ZLIB 1402| 9| { "deflate", csi_file_new_deflate_decode }, 1403| 9|#endif 1404| |#if 0 1405| | { "lzw", csi_file_new_lzw_decode }, 1406| |#endif 1407| 9| { NULL, NULL } 1408| 9| }, *filter; 1409| 9| int cnt; 1410| | 1411| 9| check (2); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 7] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 7] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 1412| | 1413| 7| status = _csi_ostack_get_string_constant (ctx, 0, &name); 1414| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 1415| 2| return status; 1416| | 1417| 5| src = _csi_peek_ostack (ctx, 1); 1418| 5| cnt = 2; 1419| 5| if (csi_object_get_type (src) == CSI_OBJECT_TYPE_DICTIONARY) { ------------------ | Branch (1419:9): [True: 0, False: 5] ------------------ 1420| 0| dict = src->datum.dictionary; 1421| | 1422| 0| check (3); ------------------ | | 93| 0|#define check(CNT) do {\ | | 94| 0| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 0| __extension__ ({ \ | | | | | | 112| 0| int _csi_boolean_var_; \ | | | | | | 113| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | | | 115| 0| else \ | | | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | | | 117| 0| _csi_boolean_var_; \ | | | | | | 118| 0|}) | | | | ------------------ | | | | | Branch (120:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 95| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 0|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 0] | | ------------------ ------------------ 1423| | 1424| 0| src = _csi_peek_ostack (ctx, 2); 1425| 0| cnt = 3; 1426| 0| } 1427| | 1428| 15| for (filter = filters; filter->name != NULL; filter++) { ------------------ | Branch (1428:28): [True: 10, False: 5] ------------------ 1429| 10| if (strcmp (name, filter->name) == 0) { ------------------ | Branch (1429:6): [True: 0, False: 10] ------------------ 1430| 0| csi_object_t file; 1431| | 1432| 0| status = filter->constructor (ctx, &file, dict, src); 1433| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 1434| 0| return status; 1435| | 1436| 0| pop (cnt); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 1437| 0| return push (&file); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 1438| 0| } 1439| 10| } 1440| | 1441| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 1442| 5|} cairo-script-operators.c:_csi_ostack_get_string_constant: 548| 7|{ 549| 7| csi_object_t *obj; 550| 7| int type; 551| | 552| 7| obj = _csi_peek_ostack (ctx, i); 553| 7| type = csi_object_get_type (obj); 554| 7| switch (type) { 555| 2| case CSI_OBJECT_TYPE_NAME: ------------------ | Branch (555:5): [True: 2, False: 5] ------------------ 556| 2| *out = (const char *) obj->datum.name; 557| 2| break; 558| 3| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (558:5): [True: 3, False: 4] ------------------ 559| 3| *out = obj->datum.string->string; 560| 3| break; 561| 2| default: ------------------ | Branch (561:5): [True: 2, False: 5] ------------------ 562| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 563| 7| } 564| 5| return CSI_STATUS_SUCCESS; 565| 7|} cairo-script-operators.c:_font: 2254| 4|{ 2255| 4| csi_dictionary_t *font; 2256| 4| csi_status_t status; 2257| 4| cairo_font_face_t *font_face = NULL; /* silence the compiler */ 2258| 4| csi_proxy_t *proxy; 2259| 4| csi_object_t obj; 2260| 4| long type; 2261| | 2262| 4| check (1); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 2263| | 2264| 3| status = _csi_ostack_get_dictionary (ctx, 0, &font); 2265| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1] | | ------------------ ------------------ 2266| 2| return status; 2267| | 2268| 1| status = _csi_dictionary_get_integer (ctx, font, "type", FALSE, &type); ------------------ | | 51| 1|#define FALSE 0 ------------------ 2269| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 2270| 1| return status; 2271| | 2272| 0| switch (type) { 2273| 0| case 3: ------------------ | Branch (2273:5): [True: 0, False: 0] ------------------ 2274| 0| status = _font_type3 (ctx, font, &font_face); 2275| 0| break; 2276| 0| case 42: ------------------ | Branch (2276:5): [True: 0, False: 0] ------------------ 2277| 0| status = _font_type42 (ctx, font, &font_face); 2278| 0| break; 2279| 0| default: ------------------ | Branch (2279:5): [True: 0, False: 0] ------------------ 2280| 0| status = _csi_error (CSI_STATUS_INVALID_SCRIPT); 2281| 0| break; 2282| 0| } 2283| | 2284| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2285| 0| return status; 2286| | 2287| | /* transfer ownership of dictionary to cairo_font_face_t */ 2288| 0| proxy = _csi_proxy_create (ctx, font_face, font, NULL, NULL); 2289| 0| if (_csi_unlikely (proxy == NULL)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2290| 0| cairo_font_face_destroy (font_face); 2291| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 2292| 0| } 2293| | 2294| 0| status = cairo_font_face_set_user_data (font_face, 2295| 0| &_csi_proxy_key, 2296| 0| proxy, _csi_proxy_destroy); 2297| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2298| 0| _csi_proxy_destroy (proxy); 2299| 0| cairo_font_face_destroy (font_face); 2300| 0| return status; 2301| 0| } 2302| | 2303| 0| obj.type = CSI_OBJECT_TYPE_FONT; 2304| 0| obj.datum.font_face = font_face; 2305| | 2306| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2307| 0| status = push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 2308| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2309| 0| cairo_font_face_destroy (font_face); 2310| 0| return status; 2311| 0| } 2312| | 2313| 0| return CSI_STATUS_SUCCESS; 2314| 0|} cairo-script-operators.c:_csi_ostack_get_dictionary: 425| 20|{ 426| 20| csi_object_t *obj; 427| | 428| 20| obj = _csi_peek_ostack (ctx, i); 429| 20| if (_csi_unlikely ------------------ | | 120| 20|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 20| __extension__ ({ \ | | | | 112| 20| int _csi_boolean_var_; \ | | | | 113| 20| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 13, False: 7] | | | | ------------------ | | | | 114| 20| _csi_boolean_var_ = 1; \ | | | | 115| 20| else \ | | | | 116| 20| _csi_boolean_var_ = 0; \ | | | | 117| 20| _csi_boolean_var_; \ | | | | 118| 20|}) | | ------------------ | | | Branch (120:29): [True: 13, False: 7] | | ------------------ ------------------ 430| 20| (csi_object_get_type (obj) != CSI_OBJECT_TYPE_DICTIONARY)) 431| 13| { 432| 13| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 433| 13| } 434| | 435| 7| *out = obj->datum.dictionary; 436| 7| return CSI_STATUS_SUCCESS; 437| 20|} cairo-script-operators.c:_csi_dictionary_get_integer: 475| 4|{ 476| 4| csi_status_t status; 477| 4| csi_object_t key, obj; 478| 4| int type; 479| | 480| 4| status = csi_name_new_static (ctx, &key, name); 481| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4] | | ------------------ ------------------ 482| 0| return status; 483| | 484| 4| if (optional && ! csi_dictionary_has (dict, key.datum.name)) ------------------ | Branch (484:9): [True: 0, False: 4] | Branch (484:21): [True: 0, False: 0] ------------------ 485| 0| return CSI_STATUS_SUCCESS; 486| | 487| 4| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 488| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 489| 4| return status; 490| | 491| 0| type = csi_object_get_type (&obj); 492| 0| switch (type) { 493| 0| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (493:5): [True: 0, False: 0] ------------------ 494| 0| *value = obj.datum.boolean; 495| 0| break; 496| 0| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (496:5): [True: 0, False: 0] ------------------ 497| 0| *value = obj.datum.integer; 498| 0| break; 499| 0| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (499:5): [True: 0, False: 0] ------------------ 500| 0| *value = obj.datum.real; 501| 0| break; 502| 0| default: ------------------ | Branch (502:5): [True: 0, False: 0] ------------------ 503| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 504| 0| } 505| 0| return CSI_STATUS_SUCCESS; 506| 0|} cairo-script-operators.c:_for: 2318| 5|{ 2319| 5| csi_array_t *proc; 2320| 5| csi_status_t status; 2321| 5| long i, inc, limit; 2322| | 2323| 5| check (4); ------------------ | | 93| 5|#define check(CNT) do {\ | | 94| 5| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 5| __extension__ ({ \ | | | | | | 112| 5| int _csi_boolean_var_; \ | | | | | | 113| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 2] | | | | | | ------------------ | | | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | | | 115| 5| else \ | | | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | | | 117| 5| _csi_boolean_var_; \ | | | | | | 118| 5|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 2] | | | | ------------------ | | ------------------ | | 95| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 5|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 2324| | 2325| 2| status = _csi_ostack_get_procedure (ctx, 0, &proc); 2326| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 2327| 2| return status; 2328| 0| status = _csi_ostack_get_integer (ctx, 1, &limit); 2329| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2330| 0| return status; 2331| 0| status = _csi_ostack_get_integer (ctx, 2, &inc); 2332| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2333| 0| return status; 2334| 0| status = _csi_ostack_get_integer (ctx, 3, &i); 2335| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2336| 0| return status; 2337| | 2338| 0| proc->base.ref++; 2339| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2340| | 2341| 0| for (; i <= limit; i += inc) { ------------------ | Branch (2341:12): [True: 0, False: 0] ------------------ 2342| 0| status = _csi_push_ostack_integer (ctx, i); 2343| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2344| 0| break; 2345| | 2346| 0| status = _csi_array_execute (ctx, proc); 2347| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2348| 0| break; 2349| 0| } 2350| | 2351| 0| if (--proc->base.ref == 0) ------------------ | Branch (2351:9): [True: 0, False: 0] ------------------ 2352| 0| csi_array_free (ctx, proc); 2353| 0| return status; 2354| 0|} cairo-script-operators.c:_gray: 2787| 8.51k|{ 2788| 8.51k| csi_object_t obj; 2789| 8.51k| csi_status_t status; 2790| 8.51k| double g; 2791| | 2792| 8.51k| check (1); ------------------ | | 93| 8.51k|#define check(CNT) do {\ | | 94| 8.51k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8.51k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8.51k| __extension__ ({ \ | | | | | | 112| 8.51k| int _csi_boolean_var_; \ | | | | | | 113| 8.51k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 8.51k] | | | | | | ------------------ | | | | | | 114| 8.51k| _csi_boolean_var_ = 1; \ | | | | | | 115| 8.51k| else \ | | | | | | 116| 8.51k| _csi_boolean_var_ = 0; \ | | | | | | 117| 8.51k| _csi_boolean_var_; \ | | | | | | 118| 8.51k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 8.51k] | | | | ------------------ | | ------------------ | | 95| 8.51k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8.51k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8.51k] | | ------------------ ------------------ 2793| | 2794| 8.51k| status = _csi_ostack_get_number (ctx, 0, &g); 2795| 8.51k| if (_csi_unlikely (status)) ------------------ | | 120| 8.51k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8.51k| __extension__ ({ \ | | | | 112| 8.51k| int _csi_boolean_var_; \ | | | | 113| 8.51k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 9, False: 8.50k] | | | | ------------------ | | | | 114| 8.51k| _csi_boolean_var_ = 1; \ | | | | 115| 8.51k| else \ | | | | 116| 8.51k| _csi_boolean_var_ = 0; \ | | | | 117| 8.51k| _csi_boolean_var_; \ | | | | 118| 8.51k|}) | | ------------------ | | | Branch (120:29): [True: 9, False: 8.50k] | | ------------------ ------------------ 2796| 9| return status; 2797| | 2798| 8.50k| pop (1); ------------------ | | 97| 8.50k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2799| | 2800| 8.50k| obj.type = CSI_OBJECT_TYPE_PATTERN; 2801| 8.50k| obj.datum.pattern = cairo_pattern_create_rgba (g, g, g, 1); 2802| 8.50k| return push (&obj); ------------------ | | 98| 8.50k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 2803| 8.51k|} cairo-script-operators.c:_ge: 2358| 7.40k|{ 2359| 7.40k| csi_status_t status; 2360| 7.40k| csi_object_t *a, *b; 2361| 7.40k| int cmp; 2362| | 2363| 7.40k| check (2); ------------------ | | 93| 7.40k|#define check(CNT) do {\ | | 94| 7.40k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7.40k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7.40k| __extension__ ({ \ | | | | | | 112| 7.40k| int _csi_boolean_var_; \ | | | | | | 113| 7.40k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 11, False: 7.39k] | | | | | | ------------------ | | | | | | 114| 7.40k| _csi_boolean_var_ = 1; \ | | | | | | 115| 7.40k| else \ | | | | | | 116| 7.40k| _csi_boolean_var_ = 0; \ | | | | | | 117| 7.40k| _csi_boolean_var_; \ | | | | | | 118| 7.40k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 11, False: 7.39k] | | | | ------------------ | | ------------------ | | 95| 7.40k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7.40k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7.39k] | | ------------------ ------------------ 2364| | 2365| 7.39k| b = _csi_peek_ostack (ctx, 0); 2366| 7.39k| a = _csi_peek_ostack (ctx, 1); 2367| | 2368| 7.39k| status = csi_object_compare (a, b, &cmp); 2369| 7.39k| if (_csi_unlikely (status)) ------------------ | | 120| 7.39k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7.39k| __extension__ ({ \ | | | | 112| 7.39k| int _csi_boolean_var_; \ | | | | 113| 7.39k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 7.39k] | | | | ------------------ | | | | 114| 7.39k| _csi_boolean_var_ = 1; \ | | | | 115| 7.39k| else \ | | | | 116| 7.39k| _csi_boolean_var_ = 0; \ | | | | 117| 7.39k| _csi_boolean_var_; \ | | | | 118| 7.39k|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 7.39k] | | ------------------ ------------------ 2370| 6| return status; 2371| | 2372| 7.39k| pop (2); ------------------ | | 97| 7.39k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2373| 7.39k| return _csi_push_ostack_boolean (ctx, cmp >= 0); 2374| 7.39k|} cairo-script-operators.c:_get: 2506| 9|{ 2507| 9| csi_object_t *key, *src, obj; 2508| 9| csi_status_t status; 2509| 9| int type; 2510| | 2511| 9| check (2); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 8] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 8] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 2512| | 2513| 8| key = _csi_peek_ostack (ctx, 0); 2514| 8| src = _csi_peek_ostack (ctx, 1); 2515| 8| pop (1); ------------------ | | 97| 8|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2516| 8| type = csi_object_get_type (src); 2517| 8| switch (type) { 2518| 1| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (2518:5): [True: 1, False: 7] ------------------ 2519| 1| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 2520| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2521| | 2522| 0| status = csi_dictionary_get (ctx, 2523| 0| src->datum.dictionary, 2524| 0| key->datum.name, 2525| 0| &obj); 2526| 0| break; 2527| 2| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (2527:5): [True: 2, False: 6] ------------------ 2528| 2| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_INTEGER)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 2529| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2530| | 2531| 0| status = csi_array_get (ctx, 2532| 0| src->datum.array, 2533| 0| key->datum.integer, 2534| 0| &obj); 2535| 0| break; 2536| |#if 0 2537| | case CSI_OBJECT_TYPE_STRING: 2538| | status = csi_string_get (src, key, &obj); 2539| | break; 2540| |#endif 2541| | 2542| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (2542:5): [True: 0, False: 8] ------------------ 2543| 0| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2544| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2545| 0| return _context_get (ctx, src->datum.cr, key->datum.name); 2546| | 2547| 0| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (2547:5): [True: 0, False: 8] ------------------ 2548| 0| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2549| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2550| 0| return _font_get (ctx, src->datum.font_face, key->datum.name); 2551| | 2552| 0| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (2552:5): [True: 0, False: 8] ------------------ 2553| 0| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2554| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2555| 0| return _pattern_get (ctx, src->datum.pattern, key->datum.name); 2556| | 2557| 0| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (2557:5): [True: 0, False: 8] ------------------ 2558| 0| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2559| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2560| 0| return _scaled_font_get (ctx, src->datum.scaled_font, key->datum.name); 2561| | 2562| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (2562:5): [True: 0, False: 8] ------------------ 2563| 0| if (_csi_unlikely (csi_object_get_type (key) != CSI_OBJECT_TYPE_NAME)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2564| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2565| 0| return _surface_get (ctx, src->datum.surface, key->datum.name); 2566| | 2567| 5| default: ------------------ | Branch (2567:5): [True: 5, False: 3] ------------------ 2568| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2569| 8| } 2570| | 2571| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2572| 0| return status; 2573| | 2574| 0| return _csi_push_ostack_copy (ctx, &obj); 2575| 0|} cairo-script-operators.c:_glyph_path: 2730| 6|{ 2731| 6| csi_array_t *array; 2732| 6| csi_status_t status; 2733| 6| cairo_t *cr; 2734| 6| cairo_glyph_t stack_glyphs[256], *glyphs; 2735| 6| csi_integer_t nglyphs, i; 2736| | 2737| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 4] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 4] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 4] | | ------------------ ------------------ 2738| | 2739| 4| status = _csi_ostack_get_array (ctx, 0, &array); 2740| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 1] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 1] | | ------------------ ------------------ 2741| 3| return status; 2742| 1| status = _csi_ostack_get_context (ctx, 1, &cr); 2743| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 2744| 1| return status; 2745| | 2746| | /* count glyphs */ 2747| 0| nglyphs = 0; 2748| 0| for (i = 0; i < array->stack.len; i++) { ------------------ | Branch (2748:17): [True: 0, False: 0] ------------------ 2749| 0| csi_object_t *obj = &array->stack.objects[i]; 2750| 0| int type = csi_object_get_type (obj); 2751| 0| switch (type) { ------------------ | Branch (2751:10): [True: 0, False: 0] ------------------ 2752| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (2752:2): [True: 0, False: 0] ------------------ 2753| 0| nglyphs += obj->datum.array->stack.len; 2754| 0| break; 2755| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (2755:2): [True: 0, False: 0] ------------------ 2756| 0| nglyphs += obj->datum.string->len; 2757| 0| break; 2758| 0| } 2759| 0| } 2760| 0| if (nglyphs == 0) { ------------------ | Branch (2760:9): [True: 0, False: 0] ------------------ 2761| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2762| 0| return CSI_STATUS_SUCCESS; 2763| 0| } 2764| | 2765| 0| if (nglyphs > ARRAY_LENGTH (stack_glyphs)) { ------------------ | | 145| 0|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (2765:9): [True: 0, False: 0] ------------------ 2766| 0| if (_csi_unlikely ((unsigned) nglyphs >= INT_MAX / sizeof (cairo_glyph_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2767| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 2768| | 2769| 0| glyphs = _csi_alloc (ctx, sizeof (cairo_glyph_t) * nglyphs); 2770| 0| if (_csi_unlikely (glyphs == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2771| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 2772| 0| } else 2773| 0| glyphs = stack_glyphs; 2774| | 2775| 0| nglyphs = _glyph_string (ctx, array, cairo_get_scaled_font (cr), glyphs); 2776| 0| cairo_glyph_path (cr, glyphs, nglyphs); 2777| | 2778| 0| if (glyphs != stack_glyphs) ------------------ | Branch (2778:9): [True: 0, False: 0] ------------------ 2779| 0| _csi_free (ctx, glyphs); 2780| | 2781| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2782| 0| return CSI_STATUS_SUCCESS; 2783| 0|} cairo-script-operators.c:_csi_ostack_get_array: 399| 42|{ 400| 42| csi_object_t *obj; 401| | 402| 42| obj = _csi_peek_ostack (ctx, i); 403| 42| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_ARRAY)) ------------------ | | 120| 42|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 42| __extension__ ({ \ | | | | 112| 42| int _csi_boolean_var_; \ | | | | 113| 42| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 36, False: 6] | | | | ------------------ | | | | 114| 42| _csi_boolean_var_ = 1; \ | | | | 115| 42| else \ | | | | 116| 42| _csi_boolean_var_ = 0; \ | | | | 117| 42| _csi_boolean_var_; \ | | | | 118| 42|}) | | ------------------ | | | Branch (120:29): [True: 36, False: 6] | | ------------------ ------------------ 404| 36| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 405| | 406| 6| *out = obj->datum.array; 407| 6| return CSI_STATUS_SUCCESS; 408| 42|} cairo-script-operators.c:_gt: 2807| 131|{ 2808| 131| csi_status_t status; 2809| 131| csi_object_t *a, *b; 2810| 131| int cmp; 2811| | 2812| 131| check (2); ------------------ | | 93| 131|#define check(CNT) do {\ | | 94| 131| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 131|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 131| __extension__ ({ \ | | | | | | 112| 131| int _csi_boolean_var_; \ | | | | | | 113| 131| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 129] | | | | | | ------------------ | | | | | | 114| 131| _csi_boolean_var_ = 1; \ | | | | | | 115| 131| else \ | | | | | | 116| 131| _csi_boolean_var_ = 0; \ | | | | | | 117| 131| _csi_boolean_var_; \ | | | | | | 118| 131|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 129] | | | | ------------------ | | ------------------ | | 95| 131| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 131|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 129] | | ------------------ ------------------ 2813| | 2814| 129| b = _csi_peek_ostack (ctx, 0); 2815| 129| a = _csi_peek_ostack (ctx, 1); 2816| | 2817| 129| status = csi_object_compare (a, b, &cmp); 2818| 129| if (_csi_unlikely (status)) ------------------ | | 120| 129|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 129| __extension__ ({ \ | | | | 112| 129| int _csi_boolean_var_; \ | | | | 113| 129| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 126] | | | | ------------------ | | | | 114| 129| _csi_boolean_var_ = 1; \ | | | | 115| 129| else \ | | | | 116| 129| _csi_boolean_var_ = 0; \ | | | | 117| 129| _csi_boolean_var_; \ | | | | 118| 129|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 126] | | ------------------ ------------------ 2819| 3| return status; 2820| | 2821| 126| pop (2); ------------------ | | 97| 126|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2822| 126| return _csi_push_ostack_boolean (ctx, cmp > 0); 2823| 129|} cairo-script-operators.c:_identity: 2827| 330|{ 2828| 330| csi_object_t obj; 2829| 330| csi_status_t status; 2830| | 2831| 330| status = csi_matrix_new (ctx, &obj); 2832| 330| if (_csi_unlikely (status)) ------------------ | | 120| 330|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 330| __extension__ ({ \ | | | | 112| 330| int _csi_boolean_var_; \ | | | | 113| 330| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 330] | | | | ------------------ | | | | 114| 330| _csi_boolean_var_ = 1; \ | | | | 115| 330| else \ | | | | 116| 330| _csi_boolean_var_ = 0; \ | | | | 117| 330| _csi_boolean_var_; \ | | | | 118| 330|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 330] | | ------------------ ------------------ 2833| 0| return status; 2834| | 2835| 330| return push (&obj); ------------------ | | 98| 330|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 2836| 330|} cairo-script-operators.c:_if: 2840| 7|{ 2841| 7| csi_array_t *proc; 2842| 7| csi_boolean_t predicate = FALSE; /* silence the compiler */ ------------------ | | 51| 7|#define FALSE 0 ------------------ 2843| 7| csi_status_t status; 2844| | 2845| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 2846| | 2847| 6| status = _csi_ostack_get_procedure (ctx, 0, &proc); 2848| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 2849| 6| return status; 2850| | 2851| 0| status = _csi_ostack_get_boolean (ctx, 1, &predicate); 2852| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2853| 0| return status; 2854| | 2855| 0| proc->base.ref++; 2856| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2857| | 2858| 0| if (predicate) ------------------ | Branch (2858:9): [True: 0, False: 0] ------------------ 2859| 0| status = _csi_array_execute (ctx, proc); 2860| | 2861| 0| if (--proc->base.ref == 0) ------------------ | Branch (2861:9): [True: 0, False: 0] ------------------ 2862| 0| csi_array_free (ctx, proc); 2863| | 2864| 0| return status; 2865| 0|} cairo-script-operators.c:_csi_ostack_get_boolean: 219| 9|{ 220| 9| csi_object_t *obj; 221| 9| int type; 222| | 223| 9| obj = _csi_peek_ostack (ctx, i); 224| 9| type = csi_object_get_type (obj); 225| 9| switch (type) { 226| 2| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (226:5): [True: 2, False: 7] ------------------ 227| 2| *out = obj->datum.boolean; 228| 2| break; 229| 5| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (229:5): [True: 5, False: 4] ------------------ 230| 5| *out = !! obj->datum.integer; 231| 5| break; 232| 1| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (232:5): [True: 1, False: 8] ------------------ 233| 1| *out = obj->datum.real != 0.; 234| 1| break; 235| 1| default: ------------------ | Branch (235:5): [True: 1, False: 8] ------------------ 236| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 237| 9| } 238| 8| return CSI_STATUS_SUCCESS; 239| 9|} cairo-script-operators.c:_ifelse: 2869| 3|{ 2870| 3| csi_array_t *true_proc, *false_proc; 2871| 3| csi_boolean_t predicate = FALSE; /* silence the compiler */ ------------------ | | 51| 3|#define FALSE 0 ------------------ 2872| 3| csi_status_t status; 2873| | 2874| 3| check (3); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 2875| | 2876| 2| status = _csi_ostack_get_procedure (ctx, 0, &false_proc); 2877| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 2878| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2879| | 2880| 0| status = _csi_ostack_get_procedure (ctx, 1, &true_proc); 2881| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2882| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 2883| | 2884| 0| status = _csi_ostack_get_boolean (ctx, 2, &predicate); 2885| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 2886| 0| return status; 2887| | 2888| 0| true_proc->base.ref++; 2889| 0| false_proc->base.ref++; 2890| 0| pop (3); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 2891| | 2892| 0| if (predicate) ------------------ | Branch (2892:9): [True: 0, False: 0] ------------------ 2893| 0| status = _csi_array_execute (ctx, true_proc); 2894| 0| else 2895| 0| status = _csi_array_execute (ctx, false_proc); 2896| | 2897| 0| if (--true_proc->base.ref == 0) ------------------ | Branch (2897:9): [True: 0, False: 0] ------------------ 2898| 0| csi_array_free (ctx, true_proc); 2899| 0| if (--false_proc->base.ref == 0) ------------------ | Branch (2899:9): [True: 0, False: 0] ------------------ 2900| 0| csi_array_free (ctx, false_proc); 2901| | 2902| 0| return status; 2903| 0|} cairo-script-operators.c:_image: 3422| 10|{ 3423| 10| csi_dictionary_t *dict; 3424| 10| cairo_surface_t *image; 3425| 10| csi_status_t status; 3426| 10| csi_object_t obj; 3427| | 3428| 10| check (1); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 9] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 9] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 9] | | ------------------ ------------------ 3429| | 3430| 9| status = _csi_ostack_get_dictionary (ctx, 0, &dict); 3431| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 3] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 3] | | ------------------ ------------------ 3432| 6| return status; 3433| | 3434| 3| status = _image_load_from_dictionary (ctx, dict, &image); 3435| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 3436| 3| return status; 3437| | 3438| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3439| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 3440| 0| obj.datum.surface = image; 3441| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3442| 3|} cairo-script-operators.c:_image_load_from_dictionary: 3329| 3|{ 3330| 3| csi_object_t obj, key; 3331| 3| long width; 3332| 3| long height; 3333| 3| long format; 3334| 3| cairo_surface_t *image = NULL; /* silence the compiler */ 3335| 3| csi_status_t status; 3336| | 3337| | /* check for "status? */ 3338| | 3339| 3| status = _csi_dictionary_get_integer (ctx, dict, "width", FALSE, &width); ------------------ | | 51| 3|#define FALSE 0 ------------------ 3340| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 3341| 3| return status; 3342| 0| status = _csi_dictionary_get_integer (ctx, dict, "height", FALSE, &height); ------------------ | | 51| 0|#define FALSE 0 ------------------ 3343| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3344| 0| return status; 3345| | 3346| 0| format = CAIRO_FORMAT_ARGB32; 3347| 0| status = _csi_dictionary_get_integer (ctx, dict, "format", TRUE, &format); ------------------ | | 55| 0|#define TRUE (!FALSE) | | ------------------ | | | | 51| 0|#define FALSE 0 | | ------------------ ------------------ 3348| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3349| 0| return status; 3350| | 3351| 0| status = csi_name_new_static (ctx, &key, "source"); 3352| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3353| 0| return status; 3354| | 3355| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (3355:9): [True: 0, False: 0] ------------------ 3356| 0| enum mime_type mime_type; 3357| 0| csi_object_t file; 3358| | 3359| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 3360| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3361| 0| return status; 3362| | 3363| 0| status = csi_name_new_static (ctx, &key, "mime-type"); 3364| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3365| 0| return status; 3366| | 3367| 0| mime_type = MIME_TYPE_NONE; 3368| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (3368:6): [True: 0, False: 0] ------------------ 3369| 0| csi_object_t type_obj; 3370| 0| const char *type_str; 3371| 0| int type; 3372| | 3373| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &type_obj); 3374| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3375| 0| return status; 3376| | 3377| 0| type = csi_object_get_type (&type_obj); 3378| 0| switch (type) { 3379| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (3379:6): [True: 0, False: 0] ------------------ 3380| 0| type_str = type_obj.datum.string->string; 3381| 0| break; 3382| 0| case CSI_OBJECT_TYPE_NAME: ------------------ | Branch (3382:6): [True: 0, False: 0] ------------------ 3383| 0| type_str = (char *) type_obj.datum.name; 3384| 0| break; 3385| 0| default: ------------------ | Branch (3385:6): [True: 0, False: 0] ------------------ 3386| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 3387| 0| } 3388| | 3389| 0| if (strcmp (type_str, CAIRO_MIME_TYPE_PNG) == 0) ------------------ | | 2621| 0|#define CAIRO_MIME_TYPE_PNG "image/png" ------------------ | Branch (3389:10): [True: 0, False: 0] ------------------ 3390| 0| mime_type = MIME_TYPE_PNG; 3391| 0| } 3392| | 3393| | 3394| | /* XXX hook for general mime-type decoder */ 3395| | 3396| 0| switch (mime_type) { ------------------ | Branch (3396:10): [True: 0, False: 0] ------------------ 3397| 0| case MIME_TYPE_NONE: ------------------ | Branch (3397:2): [True: 0, False: 0] ------------------ 3398| 0| status = _image_read_raw (ctx, &obj, format, width, height, &image); 3399| 0| break; 3400| 0| case MIME_TYPE_PNG: ------------------ | Branch (3400:2): [True: 0, False: 0] ------------------ 3401| 0| status = csi_object_as_file (ctx, &obj, &file); 3402| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3403| 0| return status; 3404| | 3405| 0| status = _image_read_png (file.datum.file, &image); 3406| 0| csi_object_free (ctx, &file); 3407| 0| break; 3408| 0| } 3409| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3410| 0| return status; 3411| | 3412| 0| image = _image_cached (ctx, image); 3413| 0| } else 3414| 0| image = cairo_image_surface_create (format, width, height); 3415| | 3416| 0| *image_out = image; 3417| 0| return CSI_STATUS_SUCCESS; 3418| 0|} cairo-script-operators.c:_index: 3446| 5.76k|{ 3447| 5.76k| csi_status_t status; 3448| 5.76k| long n; 3449| | 3450| 5.76k| check (1); ------------------ | | 93| 5.76k|#define check(CNT) do {\ | | 94| 5.76k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 5.76k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 5.76k| __extension__ ({ \ | | | | | | 112| 5.76k| int _csi_boolean_var_; \ | | | | | | 113| 5.76k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5.76k] | | | | | | ------------------ | | | | | | 114| 5.76k| _csi_boolean_var_ = 1; \ | | | | | | 115| 5.76k| else \ | | | | | | 116| 5.76k| _csi_boolean_var_ = 0; \ | | | | | | 117| 5.76k| _csi_boolean_var_; \ | | | | | | 118| 5.76k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5.76k] | | | | ------------------ | | ------------------ | | 95| 5.76k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 5.76k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5.76k] | | ------------------ ------------------ 3451| | 3452| 5.76k| status = _csi_ostack_get_integer (ctx, 0, &n); 3453| 5.76k| if (_csi_unlikely (status)) ------------------ | | 120| 5.76k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.76k| __extension__ ({ \ | | | | 112| 5.76k| int _csi_boolean_var_; \ | | | | 113| 5.76k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 5.75k] | | | | ------------------ | | | | 114| 5.76k| _csi_boolean_var_ = 1; \ | | | | 115| 5.76k| else \ | | | | 116| 5.76k| _csi_boolean_var_ = 0; \ | | | | 117| 5.76k| _csi_boolean_var_; \ | | | | 118| 5.76k|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 5.75k] | | ------------------ ------------------ 3454| 6| return status; 3455| | 3456| 5.75k| pop (1); ------------------ | | 97| 5.75k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3457| | 3458| 5.75k| check (n); ------------------ | | 93| 5.75k|#define check(CNT) do {\ | | 94| 5.75k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 5.75k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 5.75k| __extension__ ({ \ | | | | | | 112| 5.75k| int _csi_boolean_var_; \ | | | | | | 113| 5.75k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 10, False: 5.74k] | | | | | | ------------------ | | | | | | 114| 5.75k| _csi_boolean_var_ = 1; \ | | | | | | 115| 5.75k| else \ | | | | | | 116| 5.75k| _csi_boolean_var_ = 0; \ | | | | | | 117| 5.75k| _csi_boolean_var_; \ | | | | | | 118| 5.75k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 10, False: 5.74k] | | | | ------------------ | | ------------------ | | 95| 5.75k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 5.75k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5.74k] | | ------------------ ------------------ 3459| 5.74k| return _csi_push_ostack_copy (ctx, _csi_peek_ostack (ctx, n)); 3460| 5.75k|} cairo-script-operators.c:_integer: 3464| 2.18k|{ 3465| 2.18k| csi_object_t *obj; 3466| 2.18k| int type; 3467| | 3468| 2.18k| check (1); ------------------ | | 93| 2.18k|#define check(CNT) do {\ | | 94| 2.18k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2.18k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2.18k| __extension__ ({ \ | | | | | | 112| 2.18k| int _csi_boolean_var_; \ | | | | | | 113| 2.18k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2.18k] | | | | | | ------------------ | | | | | | 114| 2.18k| _csi_boolean_var_ = 1; \ | | | | | | 115| 2.18k| else \ | | | | | | 116| 2.18k| _csi_boolean_var_ = 0; \ | | | | | | 117| 2.18k| _csi_boolean_var_; \ | | | | | | 118| 2.18k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2.18k] | | | | ------------------ | | ------------------ | | 95| 2.18k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2.18k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.18k] | | ------------------ ------------------ 3469| | 3470| 2.18k| obj = _csi_peek_ostack (ctx, 0); 3471| 2.18k| type = csi_object_get_type (obj); 3472| 2.18k| switch (type) { 3473| 580| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (3473:5): [True: 580, False: 1.60k] ------------------ 3474| 580| break; 3475| 1.60k| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (3475:5): [True: 1.60k, False: 583] ------------------ 3476| 1.60k| obj->datum.integer = obj->datum.real; 3477| 1.60k| break; 3478| 3| default: ------------------ | Branch (3478:5): [True: 3, False: 2.18k] ------------------ 3479| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 3480| 2.18k| } 3481| 2.18k| obj->type = CSI_OBJECT_TYPE_INTEGER; 3482| | 3483| 2.18k| return CSI_STATUS_SUCCESS; 3484| 2.18k|} cairo-script-operators.c:_invert: 3488| 3|{ 3489| 3| csi_object_t obj; 3490| 3| csi_status_t status; 3491| 3| cairo_matrix_t m; 3492| | 3493| 3| check (1); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 3494| | 3495| 2| status = _csi_ostack_get_matrix (ctx, 0, &m); 3496| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 1] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 1] | | ------------------ ------------------ 3497| 1| return status; 3498| | 3499| 1| cairo_matrix_invert (&m); 3500| | 3501| 1| status = csi_matrix_new_from_matrix (ctx, &obj, &m); 3502| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1] | | ------------------ ------------------ 3503| 0| return status; 3504| | 3505| 1| pop (1); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3506| | 3507| 1| return push (&obj); ------------------ | | 98| 1|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3508| 1|} cairo-script-operators.c:_csi_ostack_get_matrix: 441| 25|{ 442| 25| csi_object_t *obj; 443| 25| int type; 444| | 445| 25| obj = _csi_peek_ostack (ctx, i); 446| 25| type = csi_object_get_type (obj); 447| 25| switch (type) { 448| 14| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (448:5): [True: 14, False: 11] ------------------ 449| 14| *out = obj->datum.matrix->matrix; 450| 14| return CSI_STATUS_SUCCESS; 451| | 452| 1| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (452:5): [True: 1, False: 24] ------------------ 453| 1| if (obj->datum.array->stack.len == 6) { ------------------ | Branch (453:6): [True: 0, False: 1] ------------------ 454| 0| cairo_matrix_init (out, 455| 0| csi_number_get_value (&obj->datum.array->stack.objects[0]), 456| 0| csi_number_get_value (&obj->datum.array->stack.objects[1]), 457| 0| csi_number_get_value (&obj->datum.array->stack.objects[2]), 458| 0| csi_number_get_value (&obj->datum.array->stack.objects[3]), 459| 0| csi_number_get_value (&obj->datum.array->stack.objects[4]), 460| 0| csi_number_get_value (&obj->datum.array->stack.objects[5])); 461| 0| return CSI_STATUS_SUCCESS; 462| 0| } 463| | /* else fall through */ 464| 11| default: ------------------ | Branch (464:5): [True: 10, False: 15] ------------------ 465| 11| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 466| 25| } 467| 25|} cairo-script-operators.c:_line_to: 3561| 4.07k|{ 3562| 4.07k| csi_status_t status; 3563| 4.07k| csi_object_t *obj; 3564| 4.07k| int type; 3565| 4.07k| double x, y; 3566| | 3567| 4.07k| check (3); ------------------ | | 93| 4.07k|#define check(CNT) do {\ | | 94| 4.07k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4.07k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4.07k| __extension__ ({ \ | | | | | | 112| 4.07k| int _csi_boolean_var_; \ | | | | | | 113| 4.07k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 4.06k] | | | | | | ------------------ | | | | | | 114| 4.07k| _csi_boolean_var_ = 1; \ | | | | | | 115| 4.07k| else \ | | | | | | 116| 4.07k| _csi_boolean_var_ = 0; \ | | | | | | 117| 4.07k| _csi_boolean_var_; \ | | | | | | 118| 4.07k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 4.06k] | | | | ------------------ | | ------------------ | | 95| 4.07k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4.07k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 4.06k] | | ------------------ ------------------ 3568| | 3569| 4.06k| status = _csi_ostack_get_number (ctx, 0, &y); 3570| 4.06k| if (_csi_unlikely (status)) ------------------ | | 120| 4.06k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.06k| __extension__ ({ \ | | | | 112| 4.06k| int _csi_boolean_var_; \ | | | | 113| 4.06k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4.06k] | | | | ------------------ | | | | 114| 4.06k| _csi_boolean_var_ = 1; \ | | | | 115| 4.06k| else \ | | | | 116| 4.06k| _csi_boolean_var_ = 0; \ | | | | 117| 4.06k| _csi_boolean_var_; \ | | | | 118| 4.06k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4.06k] | | ------------------ ------------------ 3571| 1| return status; 3572| 4.06k| status = _csi_ostack_get_number (ctx, 1, &x); 3573| 4.06k| if (_csi_unlikely (status)) ------------------ | | 120| 4.06k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.06k| __extension__ ({ \ | | | | 112| 4.06k| int _csi_boolean_var_; \ | | | | 113| 4.06k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4.06k] | | | | ------------------ | | | | 114| 4.06k| _csi_boolean_var_ = 1; \ | | | | 115| 4.06k| else \ | | | | 116| 4.06k| _csi_boolean_var_ = 0; \ | | | | 117| 4.06k| _csi_boolean_var_; \ | | | | 118| 4.06k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4.06k] | | ------------------ ------------------ 3574| 1| return status; 3575| | 3576| | /* XXX path object */ 3577| | 3578| 4.06k| obj = _csi_peek_ostack (ctx, 2); 3579| 4.06k| type = csi_object_get_type (obj); 3580| 4.06k| switch (type) { ------------------ | Branch (3580:13): [True: 2, False: 4.06k] ------------------ 3581| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (3581:5): [True: 0, False: 4.06k] ------------------ 3582| 0| cairo_line_to (obj->datum.cr, x, y); 3583| 0| break; 3584| 2| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (3584:5): [True: 2, False: 4.06k] ------------------ 3585| 2| cairo_mesh_pattern_line_to (obj->datum.pattern, x, y); 3586| 2| break; 3587| 4.06k| } 3588| | 3589| 4.06k| pop (2); ------------------ | | 97| 4.06k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3590| 4.06k| return CSI_STATUS_SUCCESS; 3591| 4.06k|} cairo-script-operators.c:_rel_line_to: 4283| 21|{ 4284| 21| csi_status_t status; 4285| 21| double x, y; 4286| 21| cairo_t *cr; 4287| | 4288| 21| check (3); ------------------ | | 93| 21|#define check(CNT) do {\ | | 94| 21| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 21|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 21| __extension__ ({ \ | | | | | | 112| 21| int _csi_boolean_var_; \ | | | | | | 113| 21| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 18] | | | | | | ------------------ | | | | | | 114| 21| _csi_boolean_var_ = 1; \ | | | | | | 115| 21| else \ | | | | | | 116| 21| _csi_boolean_var_ = 0; \ | | | | | | 117| 21| _csi_boolean_var_; \ | | | | | | 118| 21|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 18] | | | | ------------------ | | ------------------ | | 95| 21| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 21|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 18] | | ------------------ ------------------ 4289| | 4290| 18| status = _csi_ostack_get_number (ctx, 0, &y); 4291| 18| if (_csi_unlikely (status)) ------------------ | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 18| __extension__ ({ \ | | | | 112| 18| int _csi_boolean_var_; \ | | | | 113| 18| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 17] | | | | ------------------ | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | 115| 18| else \ | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | 117| 18| _csi_boolean_var_; \ | | | | 118| 18|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 17] | | ------------------ ------------------ 4292| 1| return status; 4293| 17| status = _csi_ostack_get_number (ctx, 1, &x); 4294| 17| if (_csi_unlikely (status)) ------------------ | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 17| __extension__ ({ \ | | | | 112| 17| int _csi_boolean_var_; \ | | | | 113| 17| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 16] | | | | ------------------ | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | 115| 17| else \ | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | 117| 17| _csi_boolean_var_; \ | | | | 118| 17|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 16] | | ------------------ ------------------ 4295| 1| return status; 4296| 16| status = _csi_ostack_get_context (ctx, 2, &cr); 4297| 16| if (_csi_unlikely (status)) ------------------ | | 120| 16|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 16| __extension__ ({ \ | | | | 112| 16| int _csi_boolean_var_; \ | | | | 113| 16| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 16, False: 0] | | | | ------------------ | | | | 114| 16| _csi_boolean_var_ = 1; \ | | | | 115| 16| else \ | | | | 116| 16| _csi_boolean_var_ = 0; \ | | | | 117| 16| _csi_boolean_var_; \ | | | | 118| 16|}) | | ------------------ | | | Branch (120:29): [True: 16, False: 0] | | ------------------ ------------------ 4298| 16| return status; 4299| | 4300| | /* XXX path object */ 4301| | 4302| 0| cairo_rel_line_to (cr, x, y); 4303| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4304| 0| return CSI_STATUS_SUCCESS; 4305| 16|} cairo-script-operators.c:_le: 3512| 27.9k|{ 3513| 27.9k| csi_status_t status; 3514| 27.9k| csi_object_t *a, *b; 3515| 27.9k| int cmp; 3516| | 3517| 27.9k| check (2); ------------------ | | 93| 27.9k|#define check(CNT) do {\ | | 94| 27.9k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 27.9k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 27.9k| __extension__ ({ \ | | | | | | 112| 27.9k| int _csi_boolean_var_; \ | | | | | | 113| 27.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 27.9k] | | | | | | ------------------ | | | | | | 114| 27.9k| _csi_boolean_var_ = 1; \ | | | | | | 115| 27.9k| else \ | | | | | | 116| 27.9k| _csi_boolean_var_ = 0; \ | | | | | | 117| 27.9k| _csi_boolean_var_; \ | | | | | | 118| 27.9k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 27.9k] | | | | ------------------ | | ------------------ | | 95| 27.9k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 27.9k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 27.9k] | | ------------------ ------------------ 3518| | 3519| 27.9k| b = _csi_peek_ostack (ctx, 0); 3520| 27.9k| a = _csi_peek_ostack (ctx, 1); 3521| | 3522| 27.9k| status = csi_object_compare (a, b, &cmp); 3523| 27.9k| if (_csi_unlikely (status)) ------------------ | | 120| 27.9k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 27.9k| __extension__ ({ \ | | | | 112| 27.9k| int _csi_boolean_var_; \ | | | | 113| 27.9k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 11, False: 27.9k] | | | | ------------------ | | | | 114| 27.9k| _csi_boolean_var_ = 1; \ | | | | 115| 27.9k| else \ | | | | 116| 27.9k| _csi_boolean_var_ = 0; \ | | | | 117| 27.9k| _csi_boolean_var_; \ | | | | 118| 27.9k|}) | | ------------------ | | | Branch (120:29): [True: 11, False: 27.9k] | | ------------------ ------------------ 3524| 11| return status; 3525| | 3526| 27.9k| pop (2); ------------------ | | 97| 27.9k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3527| 27.9k| return _csi_push_ostack_boolean (ctx, cmp <= 0); 3528| 27.9k|} cairo-script-operators.c:_linear: 3532| 10.5k|{ 3533| 10.5k| csi_object_t obj; 3534| 10.5k| csi_status_t status; 3535| 10.5k| double x1, y1, x2, y2; 3536| | 3537| 10.5k| check (4); ------------------ | | 93| 10.5k|#define check(CNT) do {\ | | 94| 10.5k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10.5k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10.5k| __extension__ ({ \ | | | | | | 112| 10.5k| int _csi_boolean_var_; \ | | | | | | 113| 10.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 15, False: 10.4k] | | | | | | ------------------ | | | | | | 114| 10.5k| _csi_boolean_var_ = 1; \ | | | | | | 115| 10.5k| else \ | | | | | | 116| 10.5k| _csi_boolean_var_ = 0; \ | | | | | | 117| 10.5k| _csi_boolean_var_; \ | | | | | | 118| 10.5k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 15, False: 10.4k] | | | | ------------------ | | ------------------ | | 95| 10.5k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10.5k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 10.4k] | | ------------------ ------------------ 3538| | 3539| 10.4k| status = _csi_ostack_get_number (ctx, 0, &y2); 3540| 10.4k| if (_csi_unlikely (status)) ------------------ | | 120| 10.4k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.4k| __extension__ ({ \ | | | | 112| 10.4k| int _csi_boolean_var_; \ | | | | 113| 10.4k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 10.4k] | | | | ------------------ | | | | 114| 10.4k| _csi_boolean_var_ = 1; \ | | | | 115| 10.4k| else \ | | | | 116| 10.4k| _csi_boolean_var_ = 0; \ | | | | 117| 10.4k| _csi_boolean_var_; \ | | | | 118| 10.4k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 10.4k] | | ------------------ ------------------ 3541| 2| return status; 3542| 10.4k| status = _csi_ostack_get_number (ctx, 1, &x2); 3543| 10.4k| if (_csi_unlikely (status)) ------------------ | | 120| 10.4k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.4k| __extension__ ({ \ | | | | 112| 10.4k| int _csi_boolean_var_; \ | | | | 113| 10.4k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 10.4k] | | | | ------------------ | | | | 114| 10.4k| _csi_boolean_var_ = 1; \ | | | | 115| 10.4k| else \ | | | | 116| 10.4k| _csi_boolean_var_ = 0; \ | | | | 117| 10.4k| _csi_boolean_var_; \ | | | | 118| 10.4k|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 10.4k] | | ------------------ ------------------ 3544| 3| return status; 3545| 10.4k| status = _csi_ostack_get_number (ctx, 2, &y1); 3546| 10.4k| if (_csi_unlikely (status)) ------------------ | | 120| 10.4k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.4k| __extension__ ({ \ | | | | 112| 10.4k| int _csi_boolean_var_; \ | | | | 113| 10.4k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 10.4k] | | | | ------------------ | | | | 114| 10.4k| _csi_boolean_var_ = 1; \ | | | | 115| 10.4k| else \ | | | | 116| 10.4k| _csi_boolean_var_ = 0; \ | | | | 117| 10.4k| _csi_boolean_var_; \ | | | | 118| 10.4k|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 10.4k] | | ------------------ ------------------ 3547| 3| return status; 3548| 10.4k| status = _csi_ostack_get_number (ctx, 3, &x1); 3549| 10.4k| if (_csi_unlikely (status)) ------------------ | | 120| 10.4k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10.4k| __extension__ ({ \ | | | | 112| 10.4k| int _csi_boolean_var_; \ | | | | 113| 10.4k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 10.4k] | | | | ------------------ | | | | 114| 10.4k| _csi_boolean_var_ = 1; \ | | | | 115| 10.4k| else \ | | | | 116| 10.4k| _csi_boolean_var_ = 0; \ | | | | 117| 10.4k| _csi_boolean_var_; \ | | | | 118| 10.4k|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 10.4k] | | ------------------ ------------------ 3550| 7| return status; 3551| | 3552| 10.4k| pop (4); ------------------ | | 97| 10.4k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3553| | 3554| 10.4k| obj.type = CSI_OBJECT_TYPE_PATTERN; 3555| 10.4k| obj.datum.pattern = cairo_pattern_create_linear (x1, y1, x2, y2); 3556| 10.4k| return push (&obj); ------------------ | | 98| 10.4k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3557| 10.4k|} cairo-script-operators.c:_lt: 3595| 2.09k|{ 3596| 2.09k| csi_status_t status; 3597| 2.09k| csi_object_t *a, *b; 3598| 2.09k| int cmp; 3599| | 3600| 2.09k| check (2); ------------------ | | 93| 2.09k|#define check(CNT) do {\ | | 94| 2.09k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2.09k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2.09k| __extension__ ({ \ | | | | | | 112| 2.09k| int _csi_boolean_var_; \ | | | | | | 113| 2.09k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 2.09k] | | | | | | ------------------ | | | | | | 114| 2.09k| _csi_boolean_var_ = 1; \ | | | | | | 115| 2.09k| else \ | | | | | | 116| 2.09k| _csi_boolean_var_ = 0; \ | | | | | | 117| 2.09k| _csi_boolean_var_; \ | | | | | | 118| 2.09k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 2.09k] | | | | ------------------ | | ------------------ | | 95| 2.09k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2.09k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.09k] | | ------------------ ------------------ 3601| | 3602| 2.09k| b = _csi_peek_ostack (ctx, 0); 3603| 2.09k| a = _csi_peek_ostack (ctx, 1); 3604| | 3605| 2.09k| status = csi_object_compare (a, b, &cmp); 3606| 2.09k| if (_csi_unlikely (status)) ------------------ | | 120| 2.09k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.09k| __extension__ ({ \ | | | | 112| 2.09k| int _csi_boolean_var_; \ | | | | 113| 2.09k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 2.09k] | | | | ------------------ | | | | 114| 2.09k| _csi_boolean_var_ = 1; \ | | | | 115| 2.09k| else \ | | | | 116| 2.09k| _csi_boolean_var_ = 0; \ | | | | 117| 2.09k| _csi_boolean_var_; \ | | | | 118| 2.09k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 2.09k] | | ------------------ ------------------ 3607| 2| return status; 3608| | 3609| 2.09k| pop (2); ------------------ | | 97| 2.09k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3610| 2.09k| return _csi_push_ostack_boolean (ctx, cmp < 0); 3611| 2.09k|} cairo-script-operators.c:_move_to: 3960| 2.11k|{ 3961| 2.11k| csi_status_t status; 3962| 2.11k| csi_object_t *obj; 3963| 2.11k| int type; 3964| 2.11k| double x, y; 3965| | 3966| 2.11k| check (3); ------------------ | | 93| 2.11k|#define check(CNT) do {\ | | 94| 2.11k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2.11k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2.11k| __extension__ ({ \ | | | | | | 112| 2.11k| int _csi_boolean_var_; \ | | | | | | 113| 2.11k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 2.11k] | | | | | | ------------------ | | | | | | 114| 2.11k| _csi_boolean_var_ = 1; \ | | | | | | 115| 2.11k| else \ | | | | | | 116| 2.11k| _csi_boolean_var_ = 0; \ | | | | | | 117| 2.11k| _csi_boolean_var_; \ | | | | | | 118| 2.11k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 2.11k] | | | | ------------------ | | ------------------ | | 95| 2.11k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2.11k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.11k] | | ------------------ ------------------ 3967| | 3968| 2.11k| status = _csi_ostack_get_number (ctx, 0, &y); 3969| 2.11k| if (_csi_unlikely (status)) ------------------ | | 120| 2.11k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.11k| __extension__ ({ \ | | | | 112| 2.11k| int _csi_boolean_var_; \ | | | | 113| 2.11k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 2.11k] | | | | ------------------ | | | | 114| 2.11k| _csi_boolean_var_ = 1; \ | | | | 115| 2.11k| else \ | | | | 116| 2.11k| _csi_boolean_var_ = 0; \ | | | | 117| 2.11k| _csi_boolean_var_; \ | | | | 118| 2.11k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 2.11k] | | ------------------ ------------------ 3970| 2| return status; 3971| 2.11k| status = _csi_ostack_get_number (ctx, 1, &x); 3972| 2.11k| if (_csi_unlikely (status)) ------------------ | | 120| 2.11k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.11k| __extension__ ({ \ | | | | 112| 2.11k| int _csi_boolean_var_; \ | | | | 113| 2.11k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 2.10k] | | | | ------------------ | | | | 114| 2.11k| _csi_boolean_var_ = 1; \ | | | | 115| 2.11k| else \ | | | | 116| 2.11k| _csi_boolean_var_ = 0; \ | | | | 117| 2.11k| _csi_boolean_var_; \ | | | | 118| 2.11k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 2.10k] | | ------------------ ------------------ 3973| 2| return status; 3974| | 3975| 2.10k| obj = _csi_peek_ostack (ctx, 2); 3976| 2.10k| type = csi_object_get_type (obj); 3977| 2.10k| switch (type) { ------------------ | Branch (3977:13): [True: 362, False: 1.74k] ------------------ 3978| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (3978:5): [True: 0, False: 2.10k] ------------------ 3979| 0| cairo_move_to (obj->datum.cr, x, y); 3980| 0| break; 3981| 362| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (3981:5): [True: 362, False: 1.74k] ------------------ 3982| 362| cairo_mesh_pattern_move_to (obj->datum.pattern, x, y); 3983| 362| break; 3984| | 3985| | /* XXX path object */ 3986| 2.10k| } 3987| | 3988| 2.10k| pop (2); ------------------ | | 97| 2.10k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3989| 2.10k| return CSI_STATUS_SUCCESS; 3990| 2.10k|} cairo-script-operators.c:_rel_move_to: 4309| 10|{ 4310| 10| csi_status_t status; 4311| 10| double x, y; 4312| 10| cairo_t *cr; 4313| | 4314| 10| check (3); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 8] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 8] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 4315| | 4316| 8| status = _csi_ostack_get_number (ctx, 0, &y); 4317| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 4] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 4] | | ------------------ ------------------ 4318| 4| return status; 4319| 4| status = _csi_ostack_get_number (ctx, 1, &x); 4320| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3] | | ------------------ ------------------ 4321| 1| return status; 4322| 3| status = _csi_ostack_get_context (ctx, 2, &cr); 4323| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 4324| 3| return status; 4325| | 4326| | /* XXX path object */ 4327| 0| cairo_rel_move_to (cr, x, y); 4328| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4329| 0| return CSI_STATUS_SUCCESS; 4330| 3|} cairo-script-operators.c:_map_to_image: 3774| 19|{ 3775| 19| csi_object_t obj; 3776| 19| csi_array_t *array; 3777| 19| csi_status_t status; 3778| 19| cairo_rectangle_int_t extents, *r; 3779| 19| cairo_surface_t *surface; 3780| | 3781| 19| check (2); ------------------ | | 93| 19|#define check(CNT) do {\ | | 94| 19| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 19|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 19| __extension__ ({ \ | | | | | | 112| 19| int _csi_boolean_var_; \ | | | | | | 113| 19| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 17] | | | | | | ------------------ | | | | | | 114| 19| _csi_boolean_var_ = 1; \ | | | | | | 115| 19| else \ | | | | | | 116| 19| _csi_boolean_var_ = 0; \ | | | | | | 117| 19| _csi_boolean_var_; \ | | | | | | 118| 19|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 17] | | | | ------------------ | | ------------------ | | 95| 19| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 19|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 17] | | ------------------ ------------------ 3782| | 3783| 17| status = _csi_ostack_get_array (ctx, 0, &array); 3784| 17| if (_csi_unlikely (status)) ------------------ | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 17| __extension__ ({ \ | | | | 112| 17| int _csi_boolean_var_; \ | | | | 113| 17| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 16, False: 1] | | | | ------------------ | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | 115| 17| else \ | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | 117| 17| _csi_boolean_var_; \ | | | | 118| 17|}) | | ------------------ | | | Branch (120:29): [True: 16, False: 1] | | ------------------ ------------------ 3785| 16| return status; 3786| | 3787| 1| status = _csi_ostack_get_surface (ctx, 1, &surface); 3788| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 3789| 1| return status; 3790| | 3791| 0| switch (array->stack.len) { 3792| 0| case 0: ------------------ | Branch (3792:5): [True: 0, False: 0] ------------------ 3793| 0| r = NULL; 3794| 0| break; 3795| 0| case 4: ------------------ | Branch (3795:5): [True: 0, False: 0] ------------------ 3796| 0| extents.x = floor (_csi_object_as_real (&array->stack.objects[0])); 3797| 0| extents.y = floor (_csi_object_as_real (&array->stack.objects[1])); 3798| 0| extents.width = ceil (_csi_object_as_real (&array->stack.objects[2])); 3799| 0| extents.height = ceil (_csi_object_as_real (&array->stack.objects[3])); 3800| 0| r = &extents; 3801| 0| break; 3802| 0| default: ------------------ | Branch (3802:5): [True: 0, False: 0] ------------------ 3803| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 3804| 0| } 3805| | 3806| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 3807| 0| obj.datum.surface = cairo_surface_reference (cairo_surface_map_to_image (surface, r)); 3808| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3809| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3810| 0|} cairo-script-operators.c:_mask: 3711| 14|{ 3712| 14| cairo_t *cr; 3713| 14| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 3714| 14| csi_status_t status; 3715| | 3716| 14| check (2); ------------------ | | 93| 14|#define check(CNT) do {\ | | 94| 14| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 14| __extension__ ({ \ | | | | | | 112| 14| int _csi_boolean_var_; \ | | | | | | 113| 14| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 12] | | | | | | ------------------ | | | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | | | 115| 14| else \ | | | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | | | 117| 14| _csi_boolean_var_; \ | | | | | | 118| 14|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 12] | | | | ------------------ | | ------------------ | | 95| 14| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 14|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 12] | | ------------------ ------------------ 3717| | 3718| 12| status = _csi_ostack_get_pattern (ctx, 0, &pattern); 3719| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 6] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 6] | | ------------------ ------------------ 3720| 6| return status; 3721| 6| status = _csi_ostack_get_context (ctx, 1, &cr); 3722| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 3723| 6| return status; 3724| | 3725| 0| cairo_mask (cr, pattern); 3726| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3727| | 3728| 0| return CSI_STATUS_SUCCESS; 3729| 6|} cairo-script-operators.c:_matrix: 3733| 1.16k|{ 3734| 1.16k| csi_object_t *obj, matrix; 3735| 1.16k| double v[6]; 3736| 1.16k| csi_status_t status; 3737| 1.16k| int n; 3738| | 3739| 1.16k| check (1); ------------------ | | 93| 1.16k|#define check(CNT) do {\ | | 94| 1.16k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 1.16k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 1.16k| __extension__ ({ \ | | | | | | 112| 1.16k| int _csi_boolean_var_; \ | | | | | | 113| 1.16k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 1.16k] | | | | | | ------------------ | | | | | | 114| 1.16k| _csi_boolean_var_ = 1; \ | | | | | | 115| 1.16k| else \ | | | | | | 116| 1.16k| _csi_boolean_var_ = 0; \ | | | | | | 117| 1.16k| _csi_boolean_var_; \ | | | | | | 118| 1.16k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 1.16k] | | | | ------------------ | | ------------------ | | 95| 1.16k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 1.16k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.16k] | | ------------------ ------------------ 3740| | 3741| 1.16k| obj = _csi_peek_ostack (ctx, 0); 3742| 1.16k| if (csi_object_is_number (obj)) { ------------------ | Branch (3742:9): [True: 1.16k, False: 3] ------------------ 3743| 1.16k| check (6); ------------------ | | 93| 1.16k|#define check(CNT) do {\ | | 94| 1.16k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 1.16k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 1.16k| __extension__ ({ \ | | | | | | 112| 1.16k| int _csi_boolean_var_; \ | | | | | | 113| 1.16k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 1.15k] | | | | | | ------------------ | | | | | | 114| 1.16k| _csi_boolean_var_ = 1; \ | | | | | | 115| 1.16k| else \ | | | | | | 116| 1.16k| _csi_boolean_var_ = 0; \ | | | | | | 117| 1.16k| _csi_boolean_var_; \ | | | | | | 118| 1.16k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 1.15k] | | | | ------------------ | | ------------------ | | 95| 1.16k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 1.16k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.15k] | | ------------------ ------------------ 3744| | 3745| 8.10k| for (n = 6; n--; ) { ------------------ | Branch (3745:14): [True: 6.94k, False: 1.15k] ------------------ 3746| 6.94k| status = _csi_ostack_get_number (ctx, 5-n, &v[n]); 3747| 6.94k| if (_csi_unlikely (status)) ------------------ | | 120| 6.94k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6.94k| __extension__ ({ \ | | | | 112| 6.94k| int _csi_boolean_var_; \ | | | | 113| 6.94k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 6.94k] | | | | ------------------ | | | | 114| 6.94k| _csi_boolean_var_ = 1; \ | | | | 115| 6.94k| else \ | | | | 116| 6.94k| _csi_boolean_var_ = 0; \ | | | | 117| 6.94k| _csi_boolean_var_; \ | | | | 118| 6.94k|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 6.94k] | | ------------------ ------------------ 3748| 4| return status; 3749| 6.94k| } 3750| 1.15k| status = csi_matrix_new_from_values (ctx, &matrix, v); 3751| 1.15k| if (_csi_unlikely (status)) ------------------ | | 120| 1.15k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.15k| __extension__ ({ \ | | | | 112| 1.15k| int _csi_boolean_var_; \ | | | | 113| 1.15k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.15k] | | | | ------------------ | | | | 114| 1.15k| _csi_boolean_var_ = 1; \ | | | | 115| 1.15k| else \ | | | | 116| 1.15k| _csi_boolean_var_ = 0; \ | | | | 117| 1.15k| _csi_boolean_var_; \ | | | | 118| 1.15k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.15k] | | ------------------ ------------------ 3752| 0| return status; 3753| | 3754| 1.15k| pop (6); ------------------ | | 97| 1.15k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3755| 1.15k| } else { 3756| 3| csi_array_t *array; 3757| | 3758| 3| status = _csi_ostack_get_array (ctx, 0, &array); 3759| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1] | | ------------------ ------------------ 3760| 2| return status; 3761| | 3762| 1| status = csi_matrix_new_from_array (ctx, &matrix, array); 3763| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 3764| 1| return status; 3765| | 3766| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3767| 0| } 3768| | 3769| 1.15k| return push (&matrix); ------------------ | | 98| 1.15k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3770| 1.16k|} cairo-script-operators.c:_mesh: 3835| 763|{ 3836| 763| csi_object_t obj; 3837| | 3838| 763| obj.type = CSI_OBJECT_TYPE_PATTERN; 3839| 763| obj.datum.pattern = cairo_pattern_create_mesh (); 3840| 763| return push (&obj); ------------------ | | 98| 763|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 3841| 763|} cairo-script-operators.c:_mesh_begin_patch: 3845| 10|{ 3846| 10| csi_status_t status; 3847| 10| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 3848| | 3849| 10| check (1); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 9] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 9] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 9] | | ------------------ ------------------ 3850| | 3851| 9| status = _csi_ostack_get_pattern (ctx, 0, &pattern); 3852| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 4] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 4] | | ------------------ ------------------ 3853| 5| return status; 3854| | 3855| 4| cairo_mesh_pattern_begin_patch (pattern); 3856| 4| return CSI_STATUS_SUCCESS; 3857| 9|} cairo-script-operators.c:_mesh_end_patch: 3861| 6|{ 3862| 6| csi_status_t status; 3863| 6| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 3864| | 3865| 6| check (1); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 3866| | 3867| 5| status = _csi_ostack_get_pattern (ctx, 0, &pattern); 3868| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 1] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 1] | | ------------------ ------------------ 3869| 4| return status; 3870| | 3871| 1| cairo_mesh_pattern_end_patch (pattern); 3872| 1| return CSI_STATUS_SUCCESS; 3873| 5|} cairo-script-operators.c:_mesh_set_control_point: 3877| 19|{ 3878| 19| csi_status_t status; 3879| 19| double x, y; 3880| 19| csi_integer_t point; 3881| 19| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 3882| | 3883| 19| check (4); ------------------ | | 93| 19|#define check(CNT) do {\ | | 94| 19| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 19|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 19| __extension__ ({ \ | | | | | | 112| 19| int _csi_boolean_var_; \ | | | | | | 113| 19| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 15] | | | | | | ------------------ | | | | | | 114| 19| _csi_boolean_var_ = 1; \ | | | | | | 115| 19| else \ | | | | | | 116| 19| _csi_boolean_var_ = 0; \ | | | | | | 117| 19| _csi_boolean_var_; \ | | | | | | 118| 19|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 15] | | | | ------------------ | | ------------------ | | 95| 19| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 19|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 15] | | ------------------ ------------------ 3884| | 3885| 15| status = _csi_ostack_get_number (ctx, 0, &y); 3886| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 12] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 12] | | ------------------ ------------------ 3887| 3| return status; 3888| 12| status = _csi_ostack_get_number (ctx, 1, &x); 3889| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 9] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 9] | | ------------------ ------------------ 3890| 3| return status; 3891| 9| status = _csi_ostack_get_integer (ctx, 2, &point); 3892| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 6] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 6] | | ------------------ ------------------ 3893| 3| return status; 3894| 6| status = _csi_ostack_get_pattern (ctx, 3, &pattern); 3895| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 3896| 6| return status; 3897| | 3898| 0| cairo_mesh_pattern_set_control_point (pattern, point, x, y); 3899| | 3900| 0| pop (3); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3901| 0| return CSI_STATUS_SUCCESS; 3902| 6|} cairo-script-operators.c:_mesh_set_corner_color: 3906| 21|{ 3907| 21| csi_status_t status; 3908| 21| double r, g, b, a; 3909| 21| csi_integer_t corner; 3910| 21| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 3911| | 3912| 21| check (6); ------------------ | | 93| 21|#define check(CNT) do {\ | | 94| 21| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 21|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 21| __extension__ ({ \ | | | | | | 112| 21| int _csi_boolean_var_; \ | | | | | | 113| 21| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 18] | | | | | | ------------------ | | | | | | 114| 21| _csi_boolean_var_ = 1; \ | | | | | | 115| 21| else \ | | | | | | 116| 21| _csi_boolean_var_ = 0; \ | | | | | | 117| 21| _csi_boolean_var_; \ | | | | | | 118| 21|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 18] | | | | ------------------ | | ------------------ | | 95| 21| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 21|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 18] | | ------------------ ------------------ 3913| | 3914| 18| status = _csi_ostack_get_number (ctx, 0, &a); 3915| 18| if (_csi_unlikely (status)) ------------------ | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 18| __extension__ ({ \ | | | | 112| 18| int _csi_boolean_var_; \ | | | | 113| 18| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 14] | | | | ------------------ | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | 115| 18| else \ | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | 117| 18| _csi_boolean_var_; \ | | | | 118| 18|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 14] | | ------------------ ------------------ 3916| 4| return status; 3917| 14| status = _csi_ostack_get_number (ctx, 1, &b); 3918| 14| if (_csi_unlikely (status)) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 14] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 14] | | ------------------ ------------------ 3919| 0| return status; 3920| 14| status = _csi_ostack_get_number (ctx, 2, &g); 3921| 14| if (_csi_unlikely (status)) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 13] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 13] | | ------------------ ------------------ 3922| 1| return status; 3923| 13| status = _csi_ostack_get_number (ctx, 3, &r); 3924| 13| if (_csi_unlikely (status)) ------------------ | | 120| 13|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13| __extension__ ({ \ | | | | 112| 13| int _csi_boolean_var_; \ | | | | 113| 13| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 12] | | | | ------------------ | | | | 114| 13| _csi_boolean_var_ = 1; \ | | | | 115| 13| else \ | | | | 116| 13| _csi_boolean_var_ = 0; \ | | | | 117| 13| _csi_boolean_var_; \ | | | | 118| 13|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 12] | | ------------------ ------------------ 3925| 1| return status; 3926| 12| status = _csi_ostack_get_integer (ctx, 4, &corner); 3927| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 12] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 12] | | ------------------ ------------------ 3928| 0| return status; 3929| 12| status = _csi_ostack_get_pattern (ctx, 5, &pattern); 3930| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 12, False: 0] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 12, False: 0] | | ------------------ ------------------ 3931| 12| return status; 3932| | 3933| 0| cairo_mesh_pattern_set_corner_color_rgba (pattern, corner, r, g, b, a); 3934| | 3935| 0| pop (5); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3936| 0| return CSI_STATUS_SUCCESS; 3937| 12|} cairo-script-operators.c:_mod: 3941| 1.15k|{ 3942| 1.15k| csi_integer_t x, y; 3943| 1.15k| csi_status_t status; 3944| | 3945| 1.15k| check (2); ------------------ | | 93| 1.15k|#define check(CNT) do {\ | | 94| 1.15k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 1.15k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 1.15k| __extension__ ({ \ | | | | | | 112| 1.15k| int _csi_boolean_var_; \ | | | | | | 113| 1.15k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 1.15k] | | | | | | ------------------ | | | | | | 114| 1.15k| _csi_boolean_var_ = 1; \ | | | | | | 115| 1.15k| else \ | | | | | | 116| 1.15k| _csi_boolean_var_ = 0; \ | | | | | | 117| 1.15k| _csi_boolean_var_; \ | | | | | | 118| 1.15k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 1.15k] | | | | ------------------ | | ------------------ | | 95| 1.15k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 1.15k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1.15k] | | ------------------ ------------------ 3946| | 3947| 1.15k| status = _csi_ostack_get_integer (ctx, 0, &y); 3948| 1.15k| if (_csi_unlikely (status)) ------------------ | | 120| 1.15k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.15k| __extension__ ({ \ | | | | 112| 1.15k| int _csi_boolean_var_; \ | | | | 113| 1.15k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1.15k] | | | | ------------------ | | | | 114| 1.15k| _csi_boolean_var_ = 1; \ | | | | 115| 1.15k| else \ | | | | 116| 1.15k| _csi_boolean_var_ = 0; \ | | | | 117| 1.15k| _csi_boolean_var_; \ | | | | 118| 1.15k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1.15k] | | ------------------ ------------------ 3949| 2| return status; 3950| 1.15k| status = _csi_ostack_get_integer (ctx, 1, &x); 3951| 1.15k| if (_csi_unlikely (status)) ------------------ | | 120| 1.15k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.15k| __extension__ ({ \ | | | | 112| 1.15k| int _csi_boolean_var_; \ | | | | 113| 1.15k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 1.14k] | | | | ------------------ | | | | 114| 1.15k| _csi_boolean_var_ = 1; \ | | | | 115| 1.15k| else \ | | | | 116| 1.15k| _csi_boolean_var_ = 0; \ | | | | 117| 1.15k| _csi_boolean_var_; \ | | | | 118| 1.15k|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 1.14k] | | ------------------ ------------------ 3952| 5| return status; 3953| | 3954| 1.14k| pop (2); ------------------ | | 97| 1.14k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3955| 1.14k| return _csi_push_ostack_integer (ctx, x % y); 3956| 1.15k|} cairo-script-operators.c:_mul: 3994| 18|{ 3995| 18| csi_object_t *A; 3996| 18| csi_object_t *B; 3997| 18| csi_object_type_t type_a, type_b; 3998| | 3999| 18| check (2); ------------------ | | 93| 18|#define check(CNT) do {\ | | 94| 18| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 18| __extension__ ({ \ | | | | | | 112| 18| int _csi_boolean_var_; \ | | | | | | 113| 18| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 15] | | | | | | ------------------ | | | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | | | 115| 18| else \ | | | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | | | 117| 18| _csi_boolean_var_; \ | | | | | | 118| 18|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 15] | | | | ------------------ | | ------------------ | | 95| 18| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 18|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 15] | | ------------------ ------------------ 4000| | 4001| 15| B = _csi_peek_ostack (ctx, 0); 4002| 15| A = _csi_peek_ostack (ctx, 1); 4003| | 4004| 15| type_a = csi_object_get_type (A); 4005| 15| if (_csi_unlikely (! (type_a == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 33| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 12, False: 3] | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 14] | | ------------------ ------------------ 4006| 15| type_a == CSI_OBJECT_TYPE_REAL))) 4007| 1| { 4008| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4009| 1| } 4010| 14| type_b = csi_object_get_type (B); 4011| 14| if (_csi_unlikely (! (type_b == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 31| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 11, False: 3] | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 13] | | ------------------ ------------------ 4012| 14| type_b == CSI_OBJECT_TYPE_REAL))) 4013| 1| { 4014| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4015| 1| } 4016| | 4017| 13| pop (2); ------------------ | | 97| 13|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4018| | 4019| 13| if (type_a == CSI_OBJECT_TYPE_REAL && ------------------ | Branch (4019:9): [True: 2, False: 11] ------------------ 4020| 2| type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (4020:2): [True: 1, False: 1] ------------------ 4021| 1| { 4022| 1| return _csi_push_ostack_real (ctx, A->datum.real * B->datum.real); 4023| | 4024| 1| } 4025| 12| else if (type_a == CSI_OBJECT_TYPE_INTEGER && ------------------ | Branch (4025:14): [True: 11, False: 1] ------------------ 4026| 11| type_b == CSI_OBJECT_TYPE_INTEGER) ------------------ | Branch (4026:7): [True: 10, False: 1] ------------------ 4027| 10| { 4028| 10| return _csi_push_ostack_integer (ctx, 4029| 10| A->datum.integer * B->datum.integer); 4030| 10| } 4031| 2| else 4032| 2| { 4033| 2| double v; 4034| | 4035| 2| if (type_a == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (4035:6): [True: 1, False: 1] ------------------ 4036| 1| v = A->datum.real; 4037| 1| else 4038| 1| v = A->datum.integer; 4039| | 4040| 2| if (type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (4040:6): [True: 1, False: 1] ------------------ 4041| 1| v *= B->datum.real; 4042| 1| else 4043| 1| v *= B->datum.integer; 4044| | 4045| 2| return _csi_push_ostack_real (ctx, v); 4046| 2| } 4047| 13|} cairo-script-operators.c:_new_path: 3691| 3|{ 3692| | /* XXX handle path object */ 3693| 3| return _do_cairo_op (ctx, cairo_new_path); 3694| 3|} cairo-script-operators.c:_new_sub_path: 3698| 9|{ 3699| | /* XXX handle path object */ 3700| 9| return _do_cairo_op (ctx, cairo_new_sub_path); 3701| 9|} cairo-script-operators.c:_ne: 3621| 6.63k|{ 3622| 6.63k| csi_object_t *a, *b; 3623| 6.63k| csi_boolean_t v; 3624| | 3625| 6.63k| check (2); ------------------ | | 93| 6.63k|#define check(CNT) do {\ | | 94| 6.63k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6.63k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6.63k| __extension__ ({ \ | | | | | | 112| 6.63k| int _csi_boolean_var_; \ | | | | | | 113| 6.63k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6.62k] | | | | | | ------------------ | | | | | | 114| 6.63k| _csi_boolean_var_ = 1; \ | | | | | | 115| 6.63k| else \ | | | | | | 116| 6.63k| _csi_boolean_var_ = 0; \ | | | | | | 117| 6.63k| _csi_boolean_var_; \ | | | | | | 118| 6.63k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6.62k] | | | | ------------------ | | ------------------ | | 95| 6.63k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6.63k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6.62k] | | ------------------ ------------------ 3626| | 3627| 6.62k| b = _csi_peek_ostack (ctx, 0); 3628| 6.62k| a = _csi_peek_ostack (ctx, 1); 3629| | 3630| 6.62k| v = ! csi_object_eq (a, b); 3631| | 3632| 6.62k| pop (2); ------------------ | | 97| 6.62k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3633| 6.62k| return _csi_push_ostack_boolean (ctx, v); 3634| 6.63k|} cairo-script-operators.c:_neg: 3638| 577|{ 3639| 577| csi_object_t *obj; 3640| 577| int type; 3641| | 3642| 577| check (1); ------------------ | | 93| 577|#define check(CNT) do {\ | | 94| 577| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 577|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 577| __extension__ ({ \ | | | | | | 112| 577| int _csi_boolean_var_; \ | | | | | | 113| 577| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 576] | | | | | | ------------------ | | | | | | 114| 577| _csi_boolean_var_ = 1; \ | | | | | | 115| 577| else \ | | | | | | 116| 577| _csi_boolean_var_ = 0; \ | | | | | | 117| 577| _csi_boolean_var_; \ | | | | | | 118| 577|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 576] | | | | ------------------ | | ------------------ | | 95| 577| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 577|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 576] | | ------------------ ------------------ 3643| | 3644| 576| obj = _csi_peek_ostack (ctx, 0); 3645| 576| type = csi_object_get_type (obj); 3646| 576| switch (type) { 3647| 352| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (3647:5): [True: 352, False: 224] ------------------ 3648| 352| obj->datum.integer = -obj->datum.integer; 3649| 352| break; 3650| 222| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (3650:5): [True: 222, False: 354] ------------------ 3651| 222| obj->datum.real = -obj->datum.real; 3652| 222| break; 3653| 2| default: ------------------ | Branch (3653:5): [True: 2, False: 574] ------------------ 3654| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 3655| 576| } 3656| | 3657| 574| return CSI_STATUS_SUCCESS; 3658| 576|} cairo-script-operators.c:_not: 3662| 3.34k|{ 3663| 3.34k| csi_object_t *obj; 3664| 3.34k| int type; 3665| | 3666| 3.34k| check (1); ------------------ | | 93| 3.34k|#define check(CNT) do {\ | | 94| 3.34k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3.34k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3.34k| __extension__ ({ \ | | | | | | 112| 3.34k| int _csi_boolean_var_; \ | | | | | | 113| 3.34k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3.34k] | | | | | | ------------------ | | | | | | 114| 3.34k| _csi_boolean_var_ = 1; \ | | | | | | 115| 3.34k| else \ | | | | | | 116| 3.34k| _csi_boolean_var_ = 0; \ | | | | | | 117| 3.34k| _csi_boolean_var_; \ | | | | | | 118| 3.34k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3.34k] | | | | ------------------ | | ------------------ | | 95| 3.34k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3.34k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3.34k] | | ------------------ ------------------ 3667| | 3668| 3.34k| obj = _csi_peek_ostack (ctx, 0); 3669| 3.34k| type = csi_object_get_type (obj); 3670| 3.34k| switch (type) { 3671| 296| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (3671:5): [True: 296, False: 3.05k] ------------------ 3672| 296| obj->datum.boolean = ! obj->datum.boolean; 3673| 296| break; 3674| 3.03k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (3674:5): [True: 3.03k, False: 316] ------------------ 3675| 3.03k| obj->type = CSI_OBJECT_TYPE_BOOLEAN; 3676| 3.03k| obj->datum.boolean = ! obj->datum.integer; 3677| 3.03k| break; 3678| 19| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (3678:5): [True: 19, False: 3.32k] ------------------ 3679| 19| obj->type = CSI_OBJECT_TYPE_BOOLEAN; 3680| 19| obj->datum.boolean = obj->datum.real == 0.0; 3681| 19| break; 3682| 1| default: ------------------ | Branch (3682:5): [True: 1, False: 3.34k] ------------------ 3683| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 3684| 3.34k| } 3685| | 3686| 3.34k| return CSI_STATUS_SUCCESS; 3687| 3.34k|} cairo-script-operators.c:_null: 3705| 21.2k|{ 3706| 21.2k| return _csi_push_ostack_null (ctx); 3707| 21.2k|} cairo-script-operators.c:_or: 4051| 22|{ 4052| 22| csi_object_t *a, *b; 4053| 22| int type; 4054| | 4055| 22| check (2); ------------------ | | 93| 22|#define check(CNT) do {\ | | 94| 22| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 22|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 22| __extension__ ({ \ | | | | | | 112| 22| int _csi_boolean_var_; \ | | | | | | 113| 22| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 18] | | | | | | ------------------ | | | | | | 114| 22| _csi_boolean_var_ = 1; \ | | | | | | 115| 22| else \ | | | | | | 116| 22| _csi_boolean_var_ = 0; \ | | | | | | 117| 22| _csi_boolean_var_; \ | | | | | | 118| 22|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 18] | | | | ------------------ | | ------------------ | | 95| 22| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 22|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 18] | | ------------------ ------------------ 4056| | 4057| 18| a = _csi_peek_ostack (ctx, 0); 4058| 18| b = _csi_peek_ostack (ctx, 1); 4059| 18| if (_csi_unlikely (csi_object_get_type (a) != csi_object_get_type (b))) ------------------ | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 18| __extension__ ({ \ | | | | 112| 18| int _csi_boolean_var_; \ | | | | 113| 18| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 17] | | | | ------------------ | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | 115| 18| else \ | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | 117| 18| _csi_boolean_var_; \ | | | | 118| 18|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 17] | | ------------------ ------------------ 4060| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4061| | 4062| 17| pop (2); ------------------ | | 97| 17|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4063| 17| type = csi_object_get_type (a); 4064| 17| switch (type) { 4065| 9| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (4065:5): [True: 9, False: 8] ------------------ 4066| 9| return _csi_push_ostack_integer (ctx, 4067| 9| a->datum.integer | b->datum.integer); 4068| 1| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (4068:5): [True: 1, False: 16] ------------------ 4069| 1| return _csi_push_ostack_boolean (ctx, 4070| 1| a->datum.boolean | b->datum.boolean); 4071| 7| default: ------------------ | Branch (4071:5): [True: 7, False: 10] ------------------ 4072| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4073| 17| } 4074| 17|} cairo-script-operators.c:_paint: 4078| 3|{ 4079| 3| return _do_cairo_op (ctx, cairo_paint); 4080| 3|} cairo-script-operators.c:_paint_with_alpha: 4084| 14|{ 4085| 14| cairo_t *cr; 4086| 14| csi_status_t status; 4087| 14| double alpha; 4088| | 4089| 14| check (2); ------------------ | | 93| 14|#define check(CNT) do {\ | | 94| 14| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 14| __extension__ ({ \ | | | | | | 112| 14| int _csi_boolean_var_; \ | | | | | | 113| 14| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 12] | | | | | | ------------------ | | | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | | | 115| 14| else \ | | | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | | | 117| 14| _csi_boolean_var_; \ | | | | | | 118| 14|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 12] | | | | ------------------ | | ------------------ | | 95| 14| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 14|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 12] | | ------------------ ------------------ 4090| | 4091| 12| status = _csi_ostack_get_number (ctx, 0, &alpha); 4092| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 8, False: 4] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 8, False: 4] | | ------------------ ------------------ 4093| 8| return status; 4094| | 4095| 4| status = _csi_ostack_get_context (ctx, 1, &cr); 4096| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 4097| 4| return status; 4098| | 4099| 0| cairo_paint_with_alpha (cr, alpha); 4100| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4101| 0| return CSI_STATUS_SUCCESS; 4102| 4|} cairo-script-operators.c:_pattern: 4106| 3|{ 4107| 3| csi_object_t obj; 4108| 3| csi_status_t status; 4109| 3| cairo_surface_t *surface; 4110| | 4111| 3| check (1); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 4112| | 4113| 2| status = _csi_ostack_get_surface (ctx, 0, &surface); 4114| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 4115| 2| return status; 4116| | 4117| 0| obj.type = CSI_OBJECT_TYPE_PATTERN; 4118| 0| obj.datum.pattern = cairo_pattern_create_for_surface (surface); 4119| | 4120| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4121| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4122| 2|} cairo-script-operators.c:_pop: 4126| 7|{ 4127| 7| check (1); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 4128| 6| pop (1); ------------------ | | 97| 6|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4129| | 4130| 6| return CSI_STATUS_SUCCESS; 4131| 7|} cairo-script-operators.c:_pop_group: 4135| 4|{ 4136| 4| csi_object_t obj; 4137| 4| csi_status_t status; 4138| 4| cairo_t *cr; 4139| | 4140| 4| check (1); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 4141| | 4142| 3| status = _csi_ostack_get_context (ctx, 0, &cr); 4143| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 4144| 3| return status; 4145| | 4146| 0| obj.type = CSI_OBJECT_TYPE_PATTERN; 4147| 0| obj.datum.pattern = cairo_pop_group (cr); 4148| | 4149| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4150| 3|} cairo-script-operators.c:_push_group: 4154| 7|{ 4155| 7| csi_status_t status; 4156| 7| cairo_t *cr; 4157| 7| long content; 4158| | 4159| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 4160| | 4161| 6| status = _csi_ostack_get_integer (ctx, 0, &content); 4162| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 4163| 1| return status; 4164| | 4165| 5| status = _csi_ostack_get_context (ctx, 1, &cr); 4166| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 4167| 5| return status; 4168| | 4169| 0| cairo_push_group_with_content (cr, content); 4170| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4171| 0| return CSI_STATUS_SUCCESS; 4172| 5|} cairo-script-operators.c:_radial: 4176| 13.7k|{ 4177| 13.7k| csi_object_t obj; 4178| 13.7k| csi_status_t status; 4179| 13.7k| double x1, y1, r1, x2, y2, r2; 4180| | 4181| 13.7k| check (6); ------------------ | | 93| 13.7k|#define check(CNT) do {\ | | 94| 13.7k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 13.7k| __extension__ ({ \ | | | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | | | 113| 13.7k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 13.7k] | | | | | | ------------------ | | | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | | | 115| 13.7k| else \ | | | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | | | 118| 13.7k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 13.7k] | | | | ------------------ | | ------------------ | | 95| 13.7k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 13.7k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 13.7k] | | ------------------ ------------------ 4182| | 4183| 13.7k| status = _csi_ostack_get_number (ctx, 0, &r2); 4184| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 13.7k] | | ------------------ ------------------ 4185| 3| return status; 4186| 13.7k| status = _csi_ostack_get_number (ctx, 1, &y2); 4187| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 13.7k] | | ------------------ ------------------ 4188| 2| return status; 4189| 13.7k| status = _csi_ostack_get_number (ctx, 2, &x2); 4190| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 13.7k] | | ------------------ ------------------ 4191| 1| return status; 4192| 13.7k| status = _csi_ostack_get_number (ctx, 3, &r1); 4193| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 13.7k] | | ------------------ ------------------ 4194| 2| return status; 4195| 13.7k| status = _csi_ostack_get_number (ctx, 4, &y1); 4196| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 13.7k] | | ------------------ ------------------ 4197| 1| return status; 4198| 13.7k| status = _csi_ostack_get_number (ctx, 5, &x1); 4199| 13.7k| if (_csi_unlikely (status)) ------------------ | | 120| 13.7k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13.7k| __extension__ ({ \ | | | | 112| 13.7k| int _csi_boolean_var_; \ | | | | 113| 13.7k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 13.7k] | | | | ------------------ | | | | 114| 13.7k| _csi_boolean_var_ = 1; \ | | | | 115| 13.7k| else \ | | | | 116| 13.7k| _csi_boolean_var_ = 0; \ | | | | 117| 13.7k| _csi_boolean_var_; \ | | | | 118| 13.7k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 13.7k] | | ------------------ ------------------ 4200| 1| return status; 4201| | 4202| 13.7k| obj.type = CSI_OBJECT_TYPE_PATTERN; 4203| 13.7k| obj.datum.pattern = cairo_pattern_create_radial (x1, y1, r1, x2, y2, r2); 4204| 13.7k| pop (6); ------------------ | | 97| 13.7k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4205| 13.7k| return push (&obj); ------------------ | | 98| 13.7k|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4206| 13.7k|} cairo-script-operators.c:_record: 6210| 8|{ 6211| 8| csi_object_t obj; 6212| 8| long content; 6213| 8| csi_array_t *array; 6214| 8| csi_status_t status; 6215| 8| cairo_rectangle_t extents; 6216| 8| cairo_rectangle_t *r; 6217| | 6218| 8| check (2); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 6] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 6] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 6219| | 6220| 6| status = _csi_ostack_get_array (ctx, 0, &array); 6221| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 2] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 2] | | ------------------ ------------------ 6222| 4| return status; 6223| | 6224| 2| status = _csi_ostack_get_integer (ctx, 1, &content); 6225| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 1] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 1] | | ------------------ ------------------ 6226| 1| return status; 6227| | 6228| 1| switch (array->stack.len) { 6229| 1| case 0: ------------------ | Branch (6229:5): [True: 1, False: 0] ------------------ 6230| 1| r = NULL; 6231| 1| break; 6232| 0| case 2: ------------------ | Branch (6232:5): [True: 0, False: 1] ------------------ 6233| 0| extents.x = extents.y = 0; 6234| 0| extents.width = _csi_object_as_real (&array->stack.objects[0]); 6235| 0| extents.height = _csi_object_as_real (&array->stack.objects[1]); 6236| 0| r = &extents; 6237| 0| break; 6238| 0| case 4: ------------------ | Branch (6238:5): [True: 0, False: 1] ------------------ 6239| 0| extents.x = _csi_object_as_real (&array->stack.objects[0]); 6240| 0| extents.y = _csi_object_as_real (&array->stack.objects[1]); 6241| 0| extents.width = _csi_object_as_real (&array->stack.objects[2]); 6242| 0| extents.height = _csi_object_as_real (&array->stack.objects[3]); 6243| 0| r = &extents; 6244| 0| break; 6245| 0| default: ------------------ | Branch (6245:5): [True: 0, False: 1] ------------------ 6246| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 6247| 1| } 6248| | 6249| 1| obj.type = CSI_OBJECT_TYPE_SURFACE; 6250| 1| obj.datum.surface = cairo_recording_surface_create (content, r); 6251| 1| pop (2); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6252| 1| return push (&obj); ------------------ | | 98| 1|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 6253| 1|} cairo-script-operators.c:_rectangle: 4210| 18|{ 4211| 18| csi_status_t status; 4212| 18| double x, y; 4213| 18| double w, h; 4214| 18| cairo_t *cr; 4215| | 4216| 18| check (5); ------------------ | | 93| 18|#define check(CNT) do {\ | | 94| 18| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 18| __extension__ ({ \ | | | | | | 112| 18| int _csi_boolean_var_; \ | | | | | | 113| 18| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 15] | | | | | | ------------------ | | | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | | | 115| 18| else \ | | | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | | | 117| 18| _csi_boolean_var_; \ | | | | | | 118| 18|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 15] | | | | ------------------ | | ------------------ | | 95| 18| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 18|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 15] | | ------------------ ------------------ 4217| | 4218| 15| status = _csi_ostack_get_number (ctx, 0, &h); 4219| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 13] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 13] | | ------------------ ------------------ 4220| 2| return status; 4221| 13| status = _csi_ostack_get_number (ctx, 1, &w); 4222| 13| if (_csi_unlikely (status)) ------------------ | | 120| 13|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 13| __extension__ ({ \ | | | | 112| 13| int _csi_boolean_var_; \ | | | | 113| 13| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 12] | | | | ------------------ | | | | 114| 13| _csi_boolean_var_ = 1; \ | | | | 115| 13| else \ | | | | 116| 13| _csi_boolean_var_ = 0; \ | | | | 117| 13| _csi_boolean_var_; \ | | | | 118| 13|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 12] | | ------------------ ------------------ 4223| 1| return status; 4224| 12| status = _csi_ostack_get_number (ctx, 2, &y); 4225| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 11] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 11] | | ------------------ ------------------ 4226| 1| return status; 4227| 11| status = _csi_ostack_get_number (ctx, 3, &x); 4228| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 9] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 9] | | ------------------ ------------------ 4229| 2| return status; 4230| 9| status = _csi_ostack_get_context (ctx, 4, &cr); 4231| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 9, False: 0] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 9, False: 0] | | ------------------ ------------------ 4232| 9| return status; 4233| | 4234| | /* XXX path object */ 4235| | 4236| 0| cairo_rectangle (cr, x, y, w, h); 4237| 0| pop(4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4238| 0| return CSI_STATUS_SUCCESS; 4239| 9|} cairo-script-operators.c:_repeat: 4334| 4|{ 4335| 4| csi_array_t *proc; 4336| 4| csi_integer_t count; 4337| 4| csi_status_t status; 4338| | 4339| 4| check (2); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 2] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 2] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 4340| | 4341| 2| status = _csi_ostack_get_procedure (ctx, 0, &proc); 4342| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 1] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 1] | | ------------------ ------------------ 4343| 1| return status; 4344| | 4345| 1| status = _csi_ostack_get_integer (ctx, 1, &count); 4346| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 4347| 1| return status; 4348| | 4349| 0| if (_csi_unlikely (count < 0)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4350| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4351| | 4352| 0| proc->base.ref++; 4353| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4354| | 4355| 0| while (count--) { ------------------ | Branch (4355:12): [True: 0, False: 0] ------------------ 4356| 0| status = _csi_array_execute (ctx, proc); 4357| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4358| 0| break; 4359| 0| } 4360| | 4361| 0| if (--proc->base.ref == 0) ------------------ | Branch (4361:9): [True: 0, False: 0] ------------------ 4362| 0| csi_array_free (ctx, proc); 4363| | 4364| 0| return status; 4365| 0|} cairo-script-operators.c:_restore: 4375| 4|{ 4376| 4| return _do_cairo_op (ctx, cairo_restore); 4377| 4|} cairo-script-operators.c:_reset_clip: 4369| 5|{ 4370| 5| return _do_cairo_op (ctx, cairo_reset_clip); 4371| 5|} cairo-script-operators.c:_rgb: 4381| 21|{ 4382| 21| csi_object_t obj; 4383| 21| csi_status_t status; 4384| 21| double r,g,b; 4385| | 4386| 21| check (3); ------------------ | | 93| 21|#define check(CNT) do {\ | | 94| 21| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 21|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 21| __extension__ ({ \ | | | | | | 112| 21| int _csi_boolean_var_; \ | | | | | | 113| 21| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 20] | | | | | | ------------------ | | | | | | 114| 21| _csi_boolean_var_ = 1; \ | | | | | | 115| 21| else \ | | | | | | 116| 21| _csi_boolean_var_ = 0; \ | | | | | | 117| 21| _csi_boolean_var_; \ | | | | | | 118| 21|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 20] | | | | ------------------ | | ------------------ | | 95| 21| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 21|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 20] | | ------------------ ------------------ 4387| | 4388| 20| status = _csi_ostack_get_number (ctx, 0, &b); 4389| 20| if (_csi_unlikely (status)) ------------------ | | 120| 20|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 20| __extension__ ({ \ | | | | 112| 20| int _csi_boolean_var_; \ | | | | 113| 20| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 18] | | | | ------------------ | | | | 114| 20| _csi_boolean_var_ = 1; \ | | | | 115| 20| else \ | | | | 116| 20| _csi_boolean_var_ = 0; \ | | | | 117| 20| _csi_boolean_var_; \ | | | | 118| 20|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 18] | | ------------------ ------------------ 4390| 2| return status; 4391| 18| status = _csi_ostack_get_number (ctx, 1, &g); 4392| 18| if (_csi_unlikely (status)) ------------------ | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 18| __extension__ ({ \ | | | | 112| 18| int _csi_boolean_var_; \ | | | | 113| 18| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 18] | | | | ------------------ | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | 115| 18| else \ | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | 117| 18| _csi_boolean_var_; \ | | | | 118| 18|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 18] | | ------------------ ------------------ 4393| 0| return status; 4394| 18| status = _csi_ostack_get_number (ctx, 2, &r); 4395| 18| if (_csi_unlikely (status)) ------------------ | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 18| __extension__ ({ \ | | | | 112| 18| int _csi_boolean_var_; \ | | | | 113| 18| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 16] | | | | ------------------ | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | 115| 18| else \ | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | 117| 18| _csi_boolean_var_; \ | | | | 118| 18|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 16] | | ------------------ ------------------ 4396| 2| return status; 4397| | 4398| 16| obj.type = CSI_OBJECT_TYPE_PATTERN; 4399| 16| obj.datum.pattern = cairo_pattern_create_rgb (r, g, b); 4400| 16| pop (3); ------------------ | | 97| 16|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4401| 16| return push (&obj); ------------------ | | 98| 16|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4402| 18|} cairo-script-operators.c:_rgba: 4406| 212|{ 4407| 212| csi_object_t obj; 4408| 212| csi_status_t status; 4409| 212| double r,g,b,a; 4410| | 4411| 212| check (4); ------------------ | | 93| 212|#define check(CNT) do {\ | | 94| 212| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 212|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 212| __extension__ ({ \ | | | | | | 112| 212| int _csi_boolean_var_; \ | | | | | | 113| 212| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 210] | | | | | | ------------------ | | | | | | 114| 212| _csi_boolean_var_ = 1; \ | | | | | | 115| 212| else \ | | | | | | 116| 212| _csi_boolean_var_ = 0; \ | | | | | | 117| 212| _csi_boolean_var_; \ | | | | | | 118| 212|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 210] | | | | ------------------ | | ------------------ | | 95| 212| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 212|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 210] | | ------------------ ------------------ 4412| | 4413| 210| status = _csi_ostack_get_number (ctx, 0, &a); 4414| 210| if (_csi_unlikely (status)) ------------------ | | 120| 210|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 210| __extension__ ({ \ | | | | 112| 210| int _csi_boolean_var_; \ | | | | 113| 210| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 209] | | | | ------------------ | | | | 114| 210| _csi_boolean_var_ = 1; \ | | | | 115| 210| else \ | | | | 116| 210| _csi_boolean_var_ = 0; \ | | | | 117| 210| _csi_boolean_var_; \ | | | | 118| 210|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 209] | | ------------------ ------------------ 4415| 1| return status; 4416| 209| status = _csi_ostack_get_number (ctx, 1, &b); 4417| 209| if (_csi_unlikely (status)) ------------------ | | 120| 209|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 209| __extension__ ({ \ | | | | 112| 209| int _csi_boolean_var_; \ | | | | 113| 209| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 207] | | | | ------------------ | | | | 114| 209| _csi_boolean_var_ = 1; \ | | | | 115| 209| else \ | | | | 116| 209| _csi_boolean_var_ = 0; \ | | | | 117| 209| _csi_boolean_var_; \ | | | | 118| 209|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 207] | | ------------------ ------------------ 4418| 2| return status; 4419| 207| status = _csi_ostack_get_number (ctx, 2, &g); 4420| 207| if (_csi_unlikely (status)) ------------------ | | 120| 207|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 207| __extension__ ({ \ | | | | 112| 207| int _csi_boolean_var_; \ | | | | 113| 207| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 206] | | | | ------------------ | | | | 114| 207| _csi_boolean_var_ = 1; \ | | | | 115| 207| else \ | | | | 116| 207| _csi_boolean_var_ = 0; \ | | | | 117| 207| _csi_boolean_var_; \ | | | | 118| 207|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 206] | | ------------------ ------------------ 4421| 1| return status; 4422| 206| status = _csi_ostack_get_number (ctx, 3, &r); 4423| 206| if (_csi_unlikely (status)) ------------------ | | 120| 206|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 206| __extension__ ({ \ | | | | 112| 206| int _csi_boolean_var_; \ | | | | 113| 206| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 205] | | | | ------------------ | | | | 114| 206| _csi_boolean_var_ = 1; \ | | | | 115| 206| else \ | | | | 116| 206| _csi_boolean_var_ = 0; \ | | | | 117| 206| _csi_boolean_var_; \ | | | | 118| 206|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 205] | | ------------------ ------------------ 4424| 1| return status; 4425| | 4426| 205| obj.type = CSI_OBJECT_TYPE_PATTERN; 4427| 205| obj.datum.pattern = cairo_pattern_create_rgba (r, g, b, a); 4428| 205| pop (4); ------------------ | | 97| 205|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4429| 205| return push (&obj); ------------------ | | 98| 205|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4430| 206|} cairo-script-operators.c:_roll: 4434| 365|{ 4435| 365| csi_status_t status; 4436| 365| long j, n; 4437| | 4438| 365| check (2); ------------------ | | 93| 365|#define check(CNT) do {\ | | 94| 365| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 365|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 365| __extension__ ({ \ | | | | | | 112| 365| int _csi_boolean_var_; \ | | | | | | 113| 365| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 361] | | | | | | ------------------ | | | | | | 114| 365| _csi_boolean_var_ = 1; \ | | | | | | 115| 365| else \ | | | | | | 116| 365| _csi_boolean_var_ = 0; \ | | | | | | 117| 365| _csi_boolean_var_; \ | | | | | | 118| 365|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 361] | | | | ------------------ | | ------------------ | | 95| 365| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 365|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 361] | | ------------------ ------------------ 4439| | 4440| 361| status = _csi_ostack_get_integer (ctx, 0, &j); 4441| 361| if (_csi_unlikely (status)) ------------------ | | 120| 361|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 361| __extension__ ({ \ | | | | 112| 361| int _csi_boolean_var_; \ | | | | 113| 361| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 360] | | | | ------------------ | | | | 114| 361| _csi_boolean_var_ = 1; \ | | | | 115| 361| else \ | | | | 116| 361| _csi_boolean_var_ = 0; \ | | | | 117| 361| _csi_boolean_var_; \ | | | | 118| 361|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 360] | | ------------------ ------------------ 4442| 1| return status; 4443| 360| status = _csi_ostack_get_integer (ctx, 1, &n); 4444| 360| if (_csi_unlikely (status)) ------------------ | | 120| 360|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 360| __extension__ ({ \ | | | | 112| 360| int _csi_boolean_var_; \ | | | | 113| 360| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 359] | | | | ------------------ | | | | 114| 360| _csi_boolean_var_ = 1; \ | | | | 115| 360| else \ | | | | 116| 360| _csi_boolean_var_ = 0; \ | | | | 117| 360| _csi_boolean_var_; \ | | | | 118| 360|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 359] | | ------------------ ------------------ 4445| 1| return status; 4446| | 4447| 359| pop (2); ------------------ | | 97| 359|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4448| 359| check (n); ------------------ | | 93| 359|#define check(CNT) do {\ | | 94| 359| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 359|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 359| __extension__ ({ \ | | | | | | 112| 359| int _csi_boolean_var_; \ | | | | | | 113| 359| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 11, False: 348] | | | | | | ------------------ | | | | | | 114| 359| _csi_boolean_var_ = 1; \ | | | | | | 115| 359| else \ | | | | | | 116| 359| _csi_boolean_var_ = 0; \ | | | | | | 117| 359| _csi_boolean_var_; \ | | | | | | 118| 359|}) | | | | ------------------ | | | | | Branch (120:29): [True: 11, False: 348] | | | | ------------------ | | ------------------ | | 95| 359| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 359|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 348] | | ------------------ ------------------ 4449| 348| return _csi_stack_roll (ctx, &ctx->ostack, j, n); 4450| 359|} cairo-script-operators.c:_rotate: 4454| 7|{ 4455| 7| csi_object_t *obj; 4456| 7| csi_status_t status; 4457| 7| double theta; 4458| 7| int type; 4459| | 4460| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 4461| | 4462| 6| status = _csi_ostack_get_number (ctx, 0, &theta); 4463| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 4464| 1| return status; 4465| | 4466| 5| obj = _csi_peek_ostack (ctx, 1); 4467| 5| type = csi_object_get_type (obj); 4468| 5| switch (type) { 4469| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (4469:5): [True: 0, False: 5] ------------------ 4470| 0| cairo_rotate (obj->datum.cr, theta); 4471| 0| break; 4472| | 4473| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (4473:5): [True: 1, False: 4] ------------------ 4474| 1| { 4475| 1| cairo_matrix_t ctm; 4476| 1| cairo_pattern_get_matrix (obj->datum.pattern, &ctm); 4477| 1| cairo_matrix_rotate (&ctm, theta); 4478| 1| cairo_pattern_set_matrix (obj->datum.pattern, &ctm); 4479| 1| } 4480| 1| break; 4481| | 4482| | 4483| 0| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (4483:5): [True: 0, False: 5] ------------------ 4484| 0| cairo_matrix_rotate (&obj->datum.matrix->matrix, theta); 4485| 0| break; 4486| | 4487| 4| default: ------------------ | Branch (4487:5): [True: 4, False: 1] ------------------ 4488| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4489| 5| } 4490| | 4491| 1| pop (1); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4492| 1| return CSI_STATUS_SUCCESS; 4493| 5|} cairo-script-operators.c:_save: 4497| 3|{ 4498| 3| return _do_cairo_op (ctx, cairo_save); 4499| 3|} cairo-script-operators.c:_scale: 4503| 6|{ 4504| 6| csi_object_t *obj; 4505| 6| csi_status_t status; 4506| 6| double x, y; 4507| 6| int type; 4508| | 4509| 6| check (3); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 4510| | 4511| 5| status = _csi_ostack_get_number (ctx, 0, &y); 4512| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 4513| 1| return status; 4514| 4| status = _csi_ostack_get_number (ctx, 1, &x); 4515| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3] | | ------------------ ------------------ 4516| 1| return status; 4517| | 4518| 3| obj = _csi_peek_ostack (ctx, 2); 4519| 3| type = csi_object_get_type (obj); 4520| 3| switch (type) { 4521| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (4521:5): [True: 0, False: 3] ------------------ 4522| 0| cairo_scale (obj->datum.cr, x, y); 4523| 0| break; 4524| | 4525| 0| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (4525:5): [True: 0, False: 3] ------------------ 4526| 0| { 4527| 0| cairo_matrix_t ctm; 4528| 0| cairo_pattern_get_matrix (obj->datum.pattern, &ctm); 4529| 0| cairo_matrix_scale (&ctm, x, y); 4530| 0| cairo_pattern_set_matrix (obj->datum.pattern, &ctm); 4531| 0| } 4532| 0| break; 4533| | 4534| | 4535| 0| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (4535:5): [True: 0, False: 3] ------------------ 4536| 0| cairo_matrix_scale (&obj->datum.matrix->matrix, x, y); 4537| 0| break; 4538| | 4539| 3| default: ------------------ | Branch (4539:5): [True: 3, False: 0] ------------------ 4540| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4541| 3| } 4542| | 4543| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4544| 0| return CSI_STATUS_SUCCESS; 4545| 3|} cairo-script-operators.c:_scaled_font: 4602| 4|{ 4603| 4| csi_object_t obj; 4604| 4| csi_dictionary_t *dict; 4605| 4| cairo_font_face_t *font_face = NULL; /* silence the compiler */ 4606| 4| cairo_matrix_t font_matrix, ctm; 4607| 4| cairo_font_options_t *options; 4608| 4| csi_status_t status; 4609| | 4610| 4| check (4); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 4611| | 4612| 3| status = _csi_ostack_get_dictionary (ctx, 0, &dict); 4613| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1] | | ------------------ ------------------ 4614| 2| return status; 4615| 1| options = cairo_font_options_create (); 4616| 1| status = _font_options_load_from_dictionary (ctx, dict, options); 4617| 1| if (_csi_unlikely (status)) { ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1] | | ------------------ ------------------ 4618| 0| cairo_font_options_destroy (options); 4619| 0| return status; 4620| 0| } 4621| | 4622| 1| status = _csi_ostack_get_matrix (ctx, 1, &ctm); 4623| 1| if (_csi_unlikely (status)) { ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 4624| 1| cairo_font_options_destroy (options); 4625| 1| return status; 4626| 1| } 4627| | 4628| 0| status = _csi_ostack_get_matrix (ctx, 2, &font_matrix); 4629| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4630| 0| cairo_font_options_destroy (options); 4631| 0| return status; 4632| 0| } 4633| | 4634| 0| status = _csi_ostack_get_font_face (ctx, 3, &font_face); 4635| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4636| 0| cairo_font_options_destroy (options); 4637| 0| return status; 4638| 0| } 4639| | 4640| 0| obj.type = CSI_OBJECT_TYPE_SCALED_FONT; 4641| 0| obj.datum.scaled_font = cairo_scaled_font_create (font_face, 4642| 0| &font_matrix, 4643| 0| &ctm, 4644| 0| options); 4645| 0| cairo_font_options_destroy (options); 4646| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4647| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 4648| 0|} cairo-script-operators.c:_font_options_load_from_dictionary: 4551| 1|{ 4552| 1| const struct { 4553| 1| const char *key; 4554| 1| void (*setter) (cairo_font_options_t *, int val); 4555| 1| } properties[] = { 4556| 1| { "antialias", 4557| 1| (void (*)(cairo_font_options_t *, int val)) 4558| 1| cairo_font_options_set_antialias }, 4559| 1| { "subpixel-order", 4560| 1| (void (*)(cairo_font_options_t *, int val)) 4561| 1| cairo_font_options_set_subpixel_order }, 4562| 1| { "hint-style", 4563| 1| (void (*)(cairo_font_options_t *, int val)) 4564| 1| cairo_font_options_set_hint_style }, 4565| 1| { "hint-metrics", 4566| 1| (void (*)(cairo_font_options_t *, int val)) 4567| 1| cairo_font_options_set_hint_metrics }, 4568| 1| { NULL, NULL }, 4569| 1| }, *prop = properties; 4570| | 4571| 5| while (prop->key != NULL) { ------------------ | Branch (4571:12): [True: 4, False: 1] ------------------ 4572| 4| csi_object_t key, value; 4573| 4| csi_status_t status; 4574| | 4575| 4| status = csi_name_new_static (ctx, &key, prop->key); 4576| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4] | | ------------------ ------------------ 4577| 0| return status; 4578| | 4579| 4| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (4579:6): [True: 0, False: 4] ------------------ 4580| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &value); 4581| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4582| 0| return status; 4583| | 4584| 0| if (_csi_unlikely (csi_object_get_type (&value) != ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4585| 0| CSI_OBJECT_TYPE_INTEGER)) 4586| 0| { 4587| 0| csi_object_free (ctx, &value); 4588| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4589| 0| } 4590| | 4591| 0| prop->setter (options, value.datum.integer); 4592| 0| } 4593| | 4594| 4| prop++; 4595| 4| } 4596| | 4597| 1| return CSI_STATUS_SUCCESS; 4598| 1|} cairo-script-operators.c:_csi_ostack_get_font_face: 335| 5|{ 336| 5| csi_object_t *obj; 337| | 338| 5| obj = _csi_peek_ostack (ctx, i); 339| 5| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_FONT)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 340| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 341| | 342| 0| *out = obj->datum.font_face; 343| 0| return CSI_STATUS_SUCCESS; 344| 5|} cairo-script-operators.c:_select_font_face: 4652| 8|{ 4653| 8| cairo_t *cr; 4654| 8| long weight; 4655| 8| long slant; 4656| 8| csi_string_t *family; 4657| 8| csi_status_t status; 4658| | 4659| 8| check (4); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 5] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 5] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 4660| | 4661| 5| status = _csi_ostack_get_integer (ctx, 0, &weight); 4662| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 4663| 1| return status; 4664| 4| status = _csi_ostack_get_integer (ctx, 1, &slant); 4665| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3] | | ------------------ ------------------ 4666| 1| return status; 4667| 3| status = _csi_ostack_get_string (ctx, 2, &family); 4668| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 4669| 3| return status; 4670| 0| status = _csi_ostack_get_context (ctx, 3, &cr); 4671| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4672| 0| return status; 4673| | 4674| 0| cairo_select_font_face (cr, family->string, slant, weight); 4675| 0| pop (3); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4676| 0| return CSI_STATUS_SUCCESS; 4677| 0|} cairo-script-operators.c:_csi_ostack_get_string: 535| 30|{ 536| 30| csi_object_t *obj; 537| | 538| 30| obj = _csi_peek_ostack (ctx, i); 539| 30| if (_csi_unlikely (csi_object_get_type (obj) != CSI_OBJECT_TYPE_STRING)) ------------------ | | 120| 30|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 30| __extension__ ({ \ | | | | 112| 30| int _csi_boolean_var_; \ | | | | 113| 30| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 25, False: 5] | | | | ------------------ | | | | 114| 30| _csi_boolean_var_ = 1; \ | | | | 115| 30| else \ | | | | 116| 30| _csi_boolean_var_ = 0; \ | | | | 117| 30| _csi_boolean_var_; \ | | | | 118| 30|}) | | ------------------ | | | Branch (120:29): [True: 25, False: 5] | | ------------------ ------------------ 540| 25| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 541| | 542| 5| *out = obj->datum.string; 543| 5| return CSI_STATUS_SUCCESS; 544| 30|} cairo-script-operators.c:_set: 4718| 10|{ 4719| 10| csi_object_t *key, *value, *dst; 4720| 10| csi_status_t status; 4721| 10| int type; 4722| | 4723| 10| check (3); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 8] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 8] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 4724| | 4725| 8| value = _csi_peek_ostack (ctx, 0); 4726| 8| key = _csi_peek_ostack (ctx, 1); 4727| 8| dst = _csi_peek_ostack (ctx, 2); 4728| | 4729| 8| type = csi_object_get_type (dst); 4730| 8| switch (type) { 4731| 1| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (4731:5): [True: 1, False: 7] ------------------ 4732| 1| if (_csi_unlikely (csi_object_get_type (key) != ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 4733| 1| CSI_OBJECT_TYPE_NAME)) 4734| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4735| | 4736| 0| status = csi_dictionary_put (ctx, 4737| 0| dst->datum.dictionary, 4738| 0| key->datum.name, 4739| 0| value); 4740| 0| break; 4741| 1| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (4741:5): [True: 1, False: 7] ------------------ 4742| 1| if (_csi_unlikely (csi_object_get_type (key) != ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 4743| 1| CSI_OBJECT_TYPE_INTEGER)) 4744| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4745| | 4746| 0| status = csi_array_put (ctx, 4747| 0| dst->datum.array, 4748| 0| key->datum.integer, 4749| 0| value); 4750| 0| break; 4751| | 4752| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (4752:5): [True: 0, False: 8] ------------------ 4753| 0| if (_csi_unlikely (csi_object_get_type (key) != ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4754| 0| CSI_OBJECT_TYPE_NAME)) 4755| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4756| | 4757| 0| status = _context_set (ctx, 4758| 0| dst->datum.cr, 4759| 0| key->datum.name, 4760| 0| value); 4761| 0| break; 4762| | 4763| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (4763:5): [True: 0, False: 8] ------------------ 4764| |#if 0 4765| | status = csi_string_put (dst, key, value); 4766| | break; 4767| |#endif 4768| 6| default: ------------------ | Branch (4768:5): [True: 6, False: 2] ------------------ 4769| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4770| 8| } 4771| | 4772| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4773| 0| return status; 4774| 8|} cairo-script-operators.c:_set_antialias: 4778| 9|{ 4779| 9| csi_status_t status; 4780| 9| cairo_t *cr; 4781| 9| long antialias; 4782| | 4783| 9| check (2); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 7] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 7] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 4784| | 4785| 7| status = _csi_ostack_get_integer (ctx, 0, &antialias); 4786| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 4787| 2| return status; 4788| 5| status = _csi_ostack_get_context (ctx, 1, &cr); 4789| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 4790| 5| return status; 4791| | 4792| 0| cairo_set_antialias (cr, antialias); 4793| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4794| 0| return CSI_STATUS_SUCCESS; 4795| 5|} cairo-script-operators.c:_set_dash: 4799| 7|{ 4800| 7| csi_array_t *array; 4801| 7| csi_status_t status; 4802| 7| cairo_t *cr; 4803| 7| double offset; 4804| | 4805| 7| check (3); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 4806| | 4807| 6| status = _csi_ostack_get_number (ctx, 0, &offset); 4808| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 4809| 1| return status; 4810| 5| status = _csi_ostack_get_array (ctx, 1, &array); 4811| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 1] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 1] | | ------------------ ------------------ 4812| 4| return status; 4813| 1| status = _csi_ostack_get_context (ctx, 2, &cr); 4814| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 4815| 1| return status; 4816| | 4817| 0| if (array->stack.len == 0) { ------------------ | Branch (4817:9): [True: 0, False: 0] ------------------ 4818| 0| cairo_set_dash (cr, NULL, 0., 0.); 4819| 0| } else { 4820| 0| double stack_dashes[8]; 4821| 0| double *dashes; 4822| 0| csi_integer_t n; 4823| | 4824| 0| if (_csi_likely (array->stack.len < ARRAY_LENGTH (stack_dashes))) { ------------------ | | 119| 0|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (119:27): [True: 0, False: 0] | | ------------------ ------------------ 4825| 0| dashes = stack_dashes; 4826| 0| } else { 4827| 0| if (_csi_unlikely ((unsigned) array->stack.len >= INT_MAX / sizeof (double))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4828| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 4829| 0| dashes = _csi_alloc (ctx, sizeof (double) * array->stack.len); 4830| 0| if (_csi_unlikely (dashes == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4831| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 4832| 0| } 4833| | 4834| 0| for (n = 0; n < array->stack.len; n++) { ------------------ | Branch (4834:14): [True: 0, False: 0] ------------------ 4835| 0| if (_csi_unlikely (! csi_object_is_number ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 4836| 0| (&array->stack.objects[n]))) 4837| 0| { 4838| 0| if (dashes != stack_dashes) ------------------ | Branch (4838:7): [True: 0, False: 0] ------------------ 4839| 0| _csi_free (ctx, dashes); 4840| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4841| 0| } 4842| | 4843| 0| dashes[n] = csi_number_get_value (&array->stack.objects[n]); 4844| 0| } 4845| | 4846| 0| cairo_set_dash (cr, dashes, n, offset); 4847| | 4848| 0| if (dashes != stack_dashes) ------------------ | Branch (4848:6): [True: 0, False: 0] ------------------ 4849| 0| _csi_free (ctx, dashes); 4850| 0| } 4851| | 4852| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4853| 0| return CSI_STATUS_SUCCESS; 4854| 0|} cairo-script-operators.c:_set_device_offset: 4858| 9|{ 4859| 9| csi_status_t status; 4860| 9| cairo_surface_t *surface; 4861| 9| double x, y; 4862| | 4863| 9| check (3); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 7] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 7] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 4864| | 4865| 7| status = _csi_ostack_get_number (ctx, 0, &y); 4866| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 4867| 2| return status; 4868| 5| status = _csi_ostack_get_number (ctx, 1, &x); 4869| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 4870| 1| return status; 4871| 4| status = _csi_ostack_get_surface (ctx, 2, &surface); 4872| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 4873| 4| return status; 4874| | 4875| 0| cairo_surface_set_device_offset (surface, x, y); 4876| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4877| 0| return CSI_STATUS_SUCCESS; 4878| 4|} cairo-script-operators.c:_set_device_scale: 4882| 11|{ 4883| 11| csi_status_t status; 4884| 11| cairo_surface_t *surface; 4885| 11| double x, y; 4886| | 4887| 11| check (3); ------------------ | | 93| 11|#define check(CNT) do {\ | | 94| 11| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 11| __extension__ ({ \ | | | | | | 112| 11| int _csi_boolean_var_; \ | | | | | | 113| 11| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 8] | | | | | | ------------------ | | | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | | | 115| 11| else \ | | | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | | | 117| 11| _csi_boolean_var_; \ | | | | | | 118| 11|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 8] | | | | ------------------ | | ------------------ | | 95| 11| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 11|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 4888| | 4889| 8| status = _csi_ostack_get_number (ctx, 0, &y); 4890| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 7] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 7] | | ------------------ ------------------ 4891| 1| return status; 4892| 7| status = _csi_ostack_get_number (ctx, 1, &x); 4893| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 6] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 6] | | ------------------ ------------------ 4894| 1| return status; 4895| 6| status = _csi_ostack_get_surface (ctx, 2, &surface); 4896| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 4897| 6| return status; 4898| | 4899| 0| cairo_surface_set_device_scale (surface, x, y); 4900| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4901| 0| return CSI_STATUS_SUCCESS; 4902| 6|} cairo-script-operators.c:_set_extend: 4906| 12|{ 4907| 12| csi_status_t status; 4908| 12| csi_object_t *obj; 4909| 12| long extend; 4910| 12| int type; 4911| | 4912| 12| check (2); ------------------ | | 93| 12|#define check(CNT) do {\ | | 94| 12| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 12| __extension__ ({ \ | | | | | | 112| 12| int _csi_boolean_var_; \ | | | | | | 113| 12| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 11] | | | | | | ------------------ | | | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | | | 115| 12| else \ | | | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | | | 117| 12| _csi_boolean_var_; \ | | | | | | 118| 12|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 11] | | | | ------------------ | | ------------------ | | 95| 12| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 12|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 11] | | ------------------ ------------------ 4913| | 4914| 11| status = _csi_ostack_get_integer (ctx, 0, &extend); 4915| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 10] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10] | | ------------------ ------------------ 4916| 1| return status; 4917| | 4918| 10| obj = _csi_peek_ostack (ctx, 1); 4919| 10| type = csi_object_get_type (obj); 4920| 10| switch (type) { 4921| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (4921:5): [True: 0, False: 10] ------------------ 4922| 0| cairo_pattern_set_extend (cairo_get_source (obj->datum.cr), 4923| 0| extend); 4924| 0| break; 4925| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (4925:5): [True: 1, False: 9] ------------------ 4926| 1| cairo_pattern_set_extend (obj->datum.pattern, extend); 4927| 1| break; 4928| 9| default: ------------------ | Branch (4928:5): [True: 9, False: 1] ------------------ 4929| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 4930| 10| } 4931| | 4932| 1| pop (1); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4933| 1| return CSI_STATUS_SUCCESS; 4934| 10|} cairo-script-operators.c:_set_fallback_resolution: 4938| 19|{ 4939| 19| csi_status_t status; 4940| 19| cairo_surface_t *surface; 4941| 19| double dpi_x, dpi_y; 4942| | 4943| 19| check (3); ------------------ | | 93| 19|#define check(CNT) do {\ | | 94| 19| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 19|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 19| __extension__ ({ \ | | | | | | 112| 19| int _csi_boolean_var_; \ | | | | | | 113| 19| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 17] | | | | | | ------------------ | | | | | | 114| 19| _csi_boolean_var_ = 1; \ | | | | | | 115| 19| else \ | | | | | | 116| 19| _csi_boolean_var_ = 0; \ | | | | | | 117| 19| _csi_boolean_var_; \ | | | | | | 118| 19|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 17] | | | | ------------------ | | ------------------ | | 95| 19| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 19|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 17] | | ------------------ ------------------ 4944| | 4945| 17| status = _csi_ostack_get_number (ctx, 0, &dpi_y); 4946| 17| if (_csi_unlikely (status)) ------------------ | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 17| __extension__ ({ \ | | | | 112| 17| int _csi_boolean_var_; \ | | | | 113| 17| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 15] | | | | ------------------ | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | 115| 17| else \ | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | 117| 17| _csi_boolean_var_; \ | | | | 118| 17|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 15] | | ------------------ ------------------ 4947| 2| return status; 4948| 15| status = _csi_ostack_get_number (ctx, 1, &dpi_x); 4949| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 11] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 11] | | ------------------ ------------------ 4950| 4| return status; 4951| 11| status = _csi_ostack_get_surface (ctx, 2, &surface); 4952| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 11, False: 0] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 11, False: 0] | | ------------------ ------------------ 4953| 11| return status; 4954| | 4955| 0| cairo_surface_set_fallback_resolution (surface, dpi_x, dpi_y); 4956| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4957| 0| return CSI_STATUS_SUCCESS; 4958| 11|} cairo-script-operators.c:_set_fill_rule: 4962| 6|{ 4963| 6| csi_status_t status; 4964| 6| cairo_t *cr; 4965| 6| long fill_rule; 4966| | 4967| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 4968| | 4969| 5| status = _csi_ostack_get_integer (ctx, 0, &fill_rule); 4970| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 4971| 1| return status; 4972| 4| status = _csi_ostack_get_context (ctx, 1, &cr); 4973| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 4974| 4| return status; 4975| | 4976| 0| cairo_set_fill_rule (cr, fill_rule); 4977| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 4978| 0| return CSI_STATUS_SUCCESS; 4979| 4|} cairo-script-operators.c:_set_filter: 4983| 7|{ 4984| 7| csi_status_t status; 4985| 7| csi_object_t *obj; 4986| 7| long filter; 4987| 7| int type; 4988| | 4989| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 4990| | 4991| 6| status = _csi_ostack_get_integer (ctx, 0, &filter); 4992| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 4993| 1| return status; 4994| | 4995| 5| obj = _csi_peek_ostack (ctx, 1); 4996| 5| type = csi_object_get_type (obj); 4997| 5| switch (type) { 4998| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (4998:5): [True: 0, False: 5] ------------------ 4999| 0| cairo_pattern_set_filter (cairo_get_source (obj->datum.cr), 5000| 0| filter); 5001| 0| break; 5002| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (5002:5): [True: 1, False: 4] ------------------ 5003| 1| cairo_pattern_set_filter (obj->datum.pattern, filter); 5004| 1| break; 5005| 4| default: ------------------ | Branch (5005:5): [True: 4, False: 1] ------------------ 5006| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5007| 5| } 5008| | 5009| 1| pop (1); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5010| 1| return CSI_STATUS_SUCCESS; 5011| 5|} cairo-script-operators.c:_set_font_face: 5015| 7|{ 5016| 7| cairo_t *cr; 5017| 7| cairo_font_face_t *font = NULL; /* silence the compiler */ 5018| 7| csi_status_t status; 5019| | 5020| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 5] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 5] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5021| | 5022| 5| status = _csi_ostack_get_font_face (ctx, 0, &font); 5023| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5024| 5| return status; 5025| 0| status = _csi_ostack_get_context (ctx, 1, &cr); 5026| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5027| 0| return status; 5028| | 5029| 0| cairo_set_font_face (cr, font); 5030| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5031| 0| return CSI_STATUS_SUCCESS; 5032| 0|} cairo-script-operators.c:_set_font_options: 5036| 3|{ 5037| 3| csi_status_t status; 5038| 3| cairo_t *cr; 5039| 3| csi_dictionary_t *dict; 5040| 3| cairo_font_options_t *options; 5041| | 5042| 3| check (2); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 5043| | 5044| 2| status = _csi_ostack_get_dictionary (ctx, 0, &dict); 5045| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 1] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 1] | | ------------------ ------------------ 5046| 1| return status; 5047| 1| status = _csi_ostack_get_context (ctx, 1, &cr); 5048| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 5049| 1| return status; 5050| | 5051| 0| options = cairo_font_options_create (); 5052| 0| status = _font_options_load_from_dictionary (ctx, dict, options); 5053| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5054| 0| return status; 5055| | 5056| 0| cairo_set_font_options (cr, options); 5057| 0| cairo_font_options_destroy (options); 5058| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5059| 0| return CSI_STATUS_SUCCESS; 5060| 0|} cairo-script-operators.c:_set_font_matrix: 5064| 3|{ 5065| 3| csi_status_t status; 5066| 3| cairo_t *cr; 5067| 3| cairo_matrix_t m; 5068| | 5069| 3| check (2); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 2] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 2] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2] | | ------------------ ------------------ 5070| | 5071| 2| status = _csi_ostack_get_matrix (ctx, 0, &m); 5072| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 5073| 2| return status; 5074| 0| status = _csi_ostack_get_context (ctx, 1, &cr); 5075| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5076| 0| return status; 5077| | 5078| 0| cairo_set_font_matrix (cr, &m); 5079| 0| pop(1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5080| 0| return CSI_STATUS_SUCCESS; 5081| 0|} cairo-script-operators.c:_set_font_size: 5085| 6|{ 5086| 6| csi_status_t status; 5087| 6| cairo_t *cr; 5088| 6| double size; 5089| | 5090| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 4] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 4] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 4] | | ------------------ ------------------ 5091| | 5092| 4| status = _csi_ostack_get_number (ctx, 0, &size); 5093| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3] | | ------------------ ------------------ 5094| 1| return status; 5095| 3| status = _csi_ostack_get_context (ctx, 1, &cr); 5096| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 5097| 3| return status; 5098| | 5099| 0| cairo_set_font_size (cr, size); 5100| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5101| 0| return CSI_STATUS_SUCCESS; 5102| 3|} cairo-script-operators.c:_set_line_cap: 5106| 6|{ 5107| 6| csi_status_t status; 5108| 6| cairo_t *cr; 5109| 6| long line_cap; 5110| | 5111| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5112| | 5113| 5| status = _csi_ostack_get_integer (ctx, 0, &line_cap); 5114| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 3] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 3] | | ------------------ ------------------ 5115| 2| return status; 5116| 3| status = _csi_ostack_get_context (ctx, 1, &cr); 5117| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 5118| 3| return status; 5119| | 5120| 0| cairo_set_line_cap (cr, line_cap); 5121| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5122| 0| return CSI_STATUS_SUCCESS; 5123| 3|} cairo-script-operators.c:_set_line_join: 5127| 4|{ 5128| 4| csi_status_t status; 5129| 4| cairo_t *cr; 5130| 4| long line_join; 5131| | 5132| 4| status = _csi_ostack_get_integer (ctx, 0, &line_join); 5133| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3] | | ------------------ ------------------ 5134| 1| return status; 5135| 3| status = _csi_ostack_get_context (ctx, 1, &cr); 5136| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 0] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 0] | | ------------------ ------------------ 5137| 3| return status; 5138| | 5139| 0| cairo_set_line_join (cr, line_join); 5140| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5141| 0| return CSI_STATUS_SUCCESS; 5142| 3|} cairo-script-operators.c:_set_line_width: 5146| 7|{ 5147| 7| csi_status_t status; 5148| 7| cairo_t *cr; 5149| 7| double line_width; 5150| | 5151| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 5] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 5] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5152| | 5153| 5| status = _csi_ostack_get_number (ctx, 0, &line_width); 5154| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 5155| 1| return status; 5156| 4| status = _csi_ostack_get_context (ctx, 1, &cr); 5157| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 5158| 4| return status; 5159| | 5160| 0| cairo_set_line_width (cr, line_width); 5161| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5162| 0| return CSI_STATUS_SUCCESS; 5163| 4|} cairo-script-operators.c:_set_hairline: 5167| 10|{ 5168| 10| csi_status_t status; 5169| 10| cairo_t *cr; 5170| 10| cairo_bool_t set_hairline = FALSE; /* silence the compiler */ ------------------ | | 51| 10|#define FALSE 0 ------------------ 5171| | 5172| 10| check (2); ------------------ | | 93| 10|#define check(CNT) do {\ | | 94| 10| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 10| __extension__ ({ \ | | | | | | 112| 10| int _csi_boolean_var_; \ | | | | | | 113| 10| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 9] | | | | | | ------------------ | | | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | | | 115| 10| else \ | | | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | | | 117| 10| _csi_boolean_var_; \ | | | | | | 118| 10|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 9] | | | | ------------------ | | ------------------ | | 95| 10| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 10|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 9] | | ------------------ ------------------ 5173| | 5174| 9| status = _csi_ostack_get_boolean (ctx, 0, &set_hairline); 5175| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 8] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 8] | | ------------------ ------------------ 5176| 1| return status; 5177| 8| status = _csi_ostack_get_context (ctx, 1, &cr); 5178| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 8, False: 0] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 8, False: 0] | | ------------------ ------------------ 5179| 8| return status; 5180| | 5181| 0| cairo_set_hairline (cr, set_hairline); 5182| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5183| 0| return CSI_STATUS_SUCCESS; 5184| 8|} cairo-script-operators.c:_set_matrix: 5188| 7|{ 5189| 7| csi_object_t *obj; 5190| 7| csi_status_t status; 5191| 7| cairo_matrix_t m; 5192| 7| int type; 5193| | 5194| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 5] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 5] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5195| | 5196| 5| status = _csi_ostack_get_matrix (ctx, 0, &m); 5197| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5198| 5| return status; 5199| | 5200| 0| obj = _csi_peek_ostack (ctx, 1); 5201| 0| type = csi_object_get_type (obj); 5202| 0| switch (type) { 5203| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (5203:5): [True: 0, False: 0] ------------------ 5204| 0| cairo_set_matrix (obj->datum.cr, &m); 5205| 0| break; 5206| 0| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (5206:5): [True: 0, False: 0] ------------------ 5207| 0| cairo_pattern_set_matrix (obj->datum.pattern, &m); 5208| 0| break; 5209| 0| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (5209:5): [True: 0, False: 0] ------------------ 5210| 0| obj->datum.matrix->matrix = m; 5211| 0| break; 5212| 0| default: ------------------ | Branch (5212:5): [True: 0, False: 0] ------------------ 5213| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5214| 0| } 5215| | 5216| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5217| 0| return CSI_STATUS_SUCCESS; 5218| 0|} cairo-script-operators.c:_set_miter_limit: 5300| 7|{ 5301| 7| csi_status_t status; 5302| 7| cairo_t *cr; 5303| 7| double miter_limit; 5304| | 5305| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 6] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 6] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 5306| | 5307| 6| status = _csi_ostack_get_number (ctx, 0, &miter_limit); 5308| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 4] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 4] | | ------------------ ------------------ 5309| 2| return status; 5310| 4| status = _csi_ostack_get_context (ctx, 1, &cr); 5311| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 5312| 4| return status; 5313| | 5314| 0| cairo_set_miter_limit (cr, miter_limit); 5315| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5316| 0| return CSI_STATUS_SUCCESS; 5317| 4|} cairo-script-operators.c:_set_mime_data: 5237| 5|{ 5238| 5| csi_status_t status; 5239| 5| csi_object_t *obj; 5240| 5| const char *mime = NULL; /* silence the compiler */ 5241| 5| csi_object_t source; 5242| 5| cairo_surface_t *surface; 5243| 5| struct _mime_tag *tag; 5244| 5| int type; 5245| | 5246| 5| check (3); ------------------ | | 93| 5|#define check(CNT) do {\ | | 94| 5| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 5| __extension__ ({ \ | | | | | | 112| 5| int _csi_boolean_var_; \ | | | | | | 113| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 3] | | | | | | ------------------ | | | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | | | 115| 5| else \ | | | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | | | 117| 5| _csi_boolean_var_; \ | | | | | | 118| 5|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 3] | | | | ------------------ | | ------------------ | | 95| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 5|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 5247| | 5248| 3| obj = _csi_peek_ostack (ctx, 0); 5249| 3| type = csi_object_get_type (obj); 5250| 3| switch (type) { 5251| 0| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (5251:5): [True: 0, False: 3] ------------------ 5252| 0| status = _csi_file_as_string (ctx, obj->datum.file, &source); 5253| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5254| 0| return status; 5255| | 5256| 0| break; 5257| | 5258| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (5258:5): [True: 0, False: 3] ------------------ 5259| 0| source = *csi_object_reference (obj); 5260| 0| break; 5261| | 5262| 3| default: ------------------ | Branch (5262:5): [True: 3, False: 0] ------------------ 5263| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5264| 3| } 5265| | 5266| 0| status = _csi_ostack_get_string_constant (ctx, 1, &mime); 5267| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5268| 0| return status; 5269| | 5270| 0| status = _csi_ostack_get_surface (ctx, 2, &surface); 5271| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5272| 0| return status; 5273| | 5274| | 5275| | /* XXX free source */ 5276| 0| tag = _csi_slab_alloc (ctx, sizeof (struct _mime_tag)); 5277| 0| if (_csi_unlikely (tag == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5278| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5279| 0| tag->ctx = cairo_script_interpreter_reference (ctx); 5280| 0| tag->source = source.datum.string; 5281| 0| tag->source->base.ref++; 5282| | 5283| 0| status = cairo_surface_set_mime_data (surface, 5284| 0| mime, 5285| 0| (uint8_t *) 5286| 0| source.datum.string->string, 5287| 0| source.datum.string->len, 5288| 0| _mime_tag_destroy, tag); 5289| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5290| 0| _mime_tag_destroy (tag); 5291| 0| return status; 5292| 0| } 5293| | 5294| 0| pop (2); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5295| 0| return CSI_STATUS_SUCCESS; 5296| 0|} cairo-script-operators.c:_set_operator: 5321| 6|{ 5322| 6| cairo_t *cr; 5323| 6| long val; 5324| 6| csi_status_t status; 5325| | 5326| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5327| | 5328| 5| status = _csi_ostack_get_integer (ctx, 0, &val); 5329| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 4] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 4] | | ------------------ ------------------ 5330| 1| return status; 5331| 4| status = _csi_ostack_get_context (ctx, 1, &cr); 5332| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 0] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 0] | | ------------------ ------------------ 5333| 4| return status; 5334| | 5335| 0| cairo_set_operator (cr, val); 5336| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5337| 0| return CSI_STATUS_SUCCESS; 5338| 4|} cairo-script-operators.c:_set_scaled_font: 5342| 7|{ 5343| 7| cairo_t *cr; 5344| 7| cairo_scaled_font_t *font = NULL; /* silence the compiler */ 5345| 7| csi_status_t status; 5346| | 5347| 7| check (2); ------------------ | | 93| 7|#define check(CNT) do {\ | | 94| 7| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 7| __extension__ ({ \ | | | | | | 112| 7| int _csi_boolean_var_; \ | | | | | | 113| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 5] | | | | | | ------------------ | | | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | | | 115| 7| else \ | | | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | | | 117| 7| _csi_boolean_var_; \ | | | | | | 118| 7|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 5] | | | | ------------------ | | ------------------ | | 95| 7| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 7|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5348| | 5349| 5| status = _csi_ostack_get_scaled_font (ctx, 0, &font); 5350| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5351| 5| return status; 5352| 0| status = _csi_ostack_get_context (ctx, 1, &cr); 5353| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5354| 0| return status; 5355| | 5356| 0| cairo_set_scaled_font (cr, font); 5357| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5358| 0| return CSI_STATUS_SUCCESS; 5359| 0|} cairo-script-operators.c:_csi_ostack_get_scaled_font: 362| 5|{ 363| 5| csi_object_t *obj; 364| | 365| 5| obj = _csi_peek_ostack (ctx, i); 366| 5| if (_csi_unlikely ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 367| 5| (csi_object_get_type (obj) != CSI_OBJECT_TYPE_SCALED_FONT)) 368| 5| { 369| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 370| 5| } 371| | 372| 0| *out = obj->datum.scaled_font; 373| 0| return CSI_STATUS_SUCCESS; 374| 5|} cairo-script-operators.c:_set_source: 5363| 2|{ 5364| 2| cairo_t *cr; 5365| 2| cairo_pattern_t *pattern = NULL; /* silence the compiler */ 5366| 2| csi_status_t status; 5367| | 5368| 2| check (2); ------------------ | | 93| 2|#define check(CNT) do {\ | | 94| 2| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2| __extension__ ({ \ | | | | | | 112| 2| int _csi_boolean_var_; \ | | | | | | 113| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 1] | | | | | | ------------------ | | | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | | | 115| 2| else \ | | | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | | | 117| 2| _csi_boolean_var_; \ | | | | | | 118| 2|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 1] | | | | ------------------ | | ------------------ | | 95| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1] | | ------------------ ------------------ 5369| | 5370| 1| status = _csi_ostack_get_pattern (ctx, 0, &pattern); 5371| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 5372| 1| return status; 5373| 0| status = _csi_ostack_get_context (ctx, 1, &cr); 5374| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5375| 0| return status; 5376| | 5377| 0| cairo_set_source (cr, pattern); 5378| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5379| 0| return CSI_STATUS_SUCCESS; 5380| 0|} cairo-script-operators.c:_set_source_image: 5414| 3|{ 5415| 3| csi_status_t status; 5416| 3| cairo_surface_t *surface; 5417| 3| cairo_surface_t *source; 5418| | 5419| 3| check (2); ------------------ | | 93| 3|#define check(CNT) do {\ | | 94| 3| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 3| __extension__ ({ \ | | | | | | 112| 3| int _csi_boolean_var_; \ | | | | | | 113| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 1] | | | | | | ------------------ | | | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | | | 115| 3| else \ | | | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | | | 117| 3| _csi_boolean_var_; \ | | | | | | 118| 3|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 1] | | | | ------------------ | | ------------------ | | 95| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 3|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 1] | | ------------------ ------------------ 5420| | 5421| 1| status = _csi_ostack_get_surface (ctx, 0, &source); 5422| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 5423| 1| return status; 5424| 0| status = _csi_ostack_get_surface (ctx, 1, &surface); 5425| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5426| 0| return status; 5427| | 5428| | /* Catch the most frequent use of simply uploading pixel data, 5429| | * principally to remove the pixman ops from the profiles. 5430| | */ 5431| 0| if (_csi_likely (_matching_images (surface, source))) { ------------------ | | 119| 0|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (119:27): [True: 0, False: 0] | | ------------------ ------------------ 5432| 0| if (cairo_surface_get_reference_count (surface) == 1 && ------------------ | Branch (5432:6): [True: 0, False: 0] ------------------ 5433| 0| cairo_surface_get_reference_count (source) == 1) ------------------ | Branch (5433:6): [True: 0, False: 0] ------------------ 5434| 0| { 5435| 0| _csi_peek_ostack (ctx, 0)->datum.surface = surface; 5436| 0| _csi_peek_ostack (ctx, 1)->datum.surface = source; 5437| 0| } 5438| 0| else 5439| 0| { 5440| 0| cairo_surface_flush (surface); 5441| 0| memcpy (cairo_image_surface_get_data (surface), 5442| 0| cairo_image_surface_get_data (source), 5443| 0| cairo_image_surface_get_height (source) * cairo_image_surface_get_stride (source)); 5444| 0| cairo_surface_mark_dirty (surface); 5445| 0| } 5446| 0| } else { 5447| 0| cairo_t *cr; 5448| | 5449| 0| cr = cairo_create (surface); 5450| 0| cairo_set_source_surface (cr, source, 0, 0); 5451| 0| cairo_paint (cr); 5452| 0| cairo_destroy (cr); 5453| 0| } 5454| | 5455| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5456| 0| return CSI_STATUS_SUCCESS; 5457| 0|} cairo-script-operators.c:_set_source_rgb: 5461| 9|{ 5462| 9| csi_status_t status; 5463| 9| double r,g,b; 5464| 9| cairo_t *cr; 5465| | 5466| 9| check (4); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 7] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 7] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 5467| | 5468| 7| status = _csi_ostack_get_number (ctx, 0, &b); 5469| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 5] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 5] | | ------------------ ------------------ 5470| 2| return status; 5471| 5| status = _csi_ostack_get_number (ctx, 1, &g); 5472| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5] | | ------------------ ------------------ 5473| 0| return status; 5474| 5| status = _csi_ostack_get_number (ctx, 2, &r); 5475| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5] | | ------------------ ------------------ 5476| 0| return status; 5477| 5| status = _csi_ostack_get_context (ctx, 3, &cr); 5478| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5479| 5| return status; 5480| | 5481| 0| cairo_set_source_rgb (cr, r, g, b); 5482| 0| pop (3); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5483| 0| return CSI_STATUS_SUCCESS; 5484| 5|} cairo-script-operators.c:_set_source_rgba: 5488| 17|{ 5489| 17| csi_status_t status; 5490| 17| double r,g,b,a; 5491| 17| cairo_t *cr; 5492| | 5493| 17| check (5); ------------------ | | 93| 17|#define check(CNT) do {\ | | 94| 17| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 17| __extension__ ({ \ | | | | | | 112| 17| int _csi_boolean_var_; \ | | | | | | 113| 17| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 3, False: 14] | | | | | | ------------------ | | | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | | | 115| 17| else \ | | | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | | | 117| 17| _csi_boolean_var_; \ | | | | | | 118| 17|}) | | | | ------------------ | | | | | Branch (120:29): [True: 3, False: 14] | | | | ------------------ | | ------------------ | | 95| 17| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 17|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 14] | | ------------------ ------------------ 5494| | 5495| 14| status = _csi_ostack_get_number (ctx, 0, &a); 5496| 14| if (_csi_unlikely (status)) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 12] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 12] | | ------------------ ------------------ 5497| 2| return status; 5498| 12| status = _csi_ostack_get_number (ctx, 1, &b); 5499| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 10] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 10] | | ------------------ ------------------ 5500| 2| return status; 5501| 10| status = _csi_ostack_get_number (ctx, 2, &g); 5502| 10| if (_csi_unlikely (status)) ------------------ | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10| __extension__ ({ \ | | | | 112| 10| int _csi_boolean_var_; \ | | | | 113| 10| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 9] | | | | ------------------ | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | 115| 10| else \ | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | 117| 10| _csi_boolean_var_; \ | | | | 118| 10|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 9] | | ------------------ ------------------ 5503| 1| return status; 5504| 9| status = _csi_ostack_get_number (ctx, 3, &r); 5505| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 7] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 7] | | ------------------ ------------------ 5506| 2| return status; 5507| 7| status = _csi_ostack_get_context (ctx, 4, &cr); 5508| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 0] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 0] | | ------------------ ------------------ 5509| 7| return status; 5510| | 5511| 0| cairo_set_source_rgba (cr, r, g, b, a); 5512| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5513| 0| return CSI_STATUS_SUCCESS; 5514| 7|} cairo-script-operators.c:_set_tolerance: 5518| 8|{ 5519| 8| csi_status_t status; 5520| 8| cairo_t *cr; 5521| 8| double tolerance; 5522| | 5523| 8| check (2); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 7] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 7] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 5524| | 5525| 7| status = _csi_ostack_get_number (ctx, 0, &tolerance); 5526| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 6] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 6] | | ------------------ ------------------ 5527| 1| return status; 5528| 6| status = _csi_ostack_get_context (ctx, 1, &cr); 5529| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 5530| 6| return status; 5531| | 5532| 0| cairo_set_tolerance (cr, tolerance); 5533| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5534| 0| return CSI_STATUS_SUCCESS; 5535| 6|} cairo-script-operators.c:_show_glyphs: 5796| 9|{ 5797| 9| csi_array_t *array; 5798| 9| csi_status_t status; 5799| 9| cairo_t *cr; 5800| 9| cairo_glyph_t stack_glyphs[256], *glyphs; 5801| 9| csi_integer_t nglyphs, i; 5802| | 5803| 9| check (2); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 7] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 7] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 7] | | ------------------ ------------------ 5804| | 5805| 7| status = _csi_ostack_get_array (ctx, 0, &array); 5806| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 0] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 0] | | ------------------ ------------------ 5807| 7| return status; 5808| 0| status = _csi_ostack_get_context (ctx, 1, &cr); 5809| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5810| 0| return status; 5811| | 5812| | /* count glyphs */ 5813| 0| nglyphs = 0; 5814| 0| for (i = 0; i < array->stack.len; i++) { ------------------ | Branch (5814:17): [True: 0, False: 0] ------------------ 5815| 0| csi_object_t *obj = &array->stack.objects[i]; 5816| 0| int type = csi_object_get_type (obj); 5817| 0| switch (type) { ------------------ | Branch (5817:10): [True: 0, False: 0] ------------------ 5818| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (5818:2): [True: 0, False: 0] ------------------ 5819| 0| nglyphs += obj->datum.array->stack.len; 5820| 0| break; 5821| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (5821:2): [True: 0, False: 0] ------------------ 5822| 0| nglyphs += obj->datum.string->len; 5823| 0| break; 5824| 0| } 5825| 0| } 5826| 0| if (nglyphs == 0) { ------------------ | Branch (5826:9): [True: 0, False: 0] ------------------ 5827| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5828| 0| return CSI_STATUS_SUCCESS; 5829| 0| } 5830| | 5831| 0| if (nglyphs > ARRAY_LENGTH (stack_glyphs)) { ------------------ | | 145| 0|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (5831:9): [True: 0, False: 0] ------------------ 5832| 0| if (_csi_unlikely ((unsigned) nglyphs >= INT_MAX / sizeof (cairo_glyph_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5833| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5834| | 5835| 0| glyphs = _csi_alloc (ctx, sizeof (cairo_glyph_t) * nglyphs); 5836| 0| if (_csi_unlikely (glyphs == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5837| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5838| 0| } else 5839| 0| glyphs = stack_glyphs; 5840| | 5841| 0| nglyphs = _glyph_string (ctx, array, cairo_get_scaled_font (cr), glyphs); 5842| 0| cairo_show_glyphs (cr, glyphs, nglyphs); 5843| | 5844| 0| if (glyphs != stack_glyphs) ------------------ | Branch (5844:9): [True: 0, False: 0] ------------------ 5845| 0| _csi_free (ctx, glyphs); 5846| | 5847| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5848| 0| return CSI_STATUS_SUCCESS; 5849| 0|} cairo-script-operators.c:_show_text: 5775| 4|{ 5776| 4| csi_status_t status; 5777| 4| csi_string_t *text; 5778| 4| cairo_t *cr; 5779| | 5780| 4| check (2); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 5781| | 5782| 3| status = _csi_ostack_get_string (ctx, 0, &text); 5783| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1] | | ------------------ ------------------ 5784| 2| return status; 5785| 1| status = _csi_ostack_get_context (ctx, 1, &cr); 5786| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 5787| 1| return status; 5788| | 5789| 0| cairo_show_text (cr, text->string); 5790| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5791| 0| return CSI_STATUS_SUCCESS; 5792| 1|} cairo-script-operators.c:_show_text_glyphs: 5853| 9|{ 5854| 9| csi_object_t *obj; 5855| 9| csi_array_t *array; 5856| 9| csi_string_t *string; 5857| 9| csi_string_t *utf8_string; 5858| 9| csi_status_t status; 5859| 9| cairo_t *cr; 5860| 9| cairo_text_cluster_t stack_clusters[256], *clusters; 5861| 9| cairo_glyph_t stack_glyphs[256], *glyphs; 5862| 9| csi_integer_t nglyphs, nclusters, i; 5863| 9| long direction; 5864| 9| int type; 5865| | 5866| 9| check (5); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 5] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 5] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5867| | 5868| 5| status = _csi_ostack_get_integer (ctx, 0, &direction); 5869| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 3] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 3] | | ------------------ ------------------ 5870| 2| return status; 5871| | 5872| 3| obj = _csi_peek_ostack (ctx, 1); 5873| 3| type = csi_object_get_type (obj); 5874| 3| switch (type) { 5875| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (5875:5): [True: 0, False: 3] ------------------ 5876| 0| array = obj->datum.array; 5877| 0| nclusters = array->stack.len / 2; 5878| 0| if (nclusters > ARRAY_LENGTH (stack_clusters)) { ------------------ | | 145| 0|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (5878:6): [True: 0, False: 0] ------------------ 5879| 0| if (_csi_unlikely ((unsigned) nclusters >= INT_MAX / sizeof (cairo_text_cluster_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5880| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5881| 0| clusters = _csi_alloc (ctx, sizeof (cairo_text_cluster_t) * nclusters); 5882| 0| if (_csi_unlikely (clusters == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5883| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5884| 0| } else 5885| 0| clusters = stack_clusters; 5886| | 5887| 0| for (i = 0; i < nclusters; i++) { ------------------ | Branch (5887:14): [True: 0, False: 0] ------------------ 5888| 0| clusters[i].num_bytes = csi_number_get_value (&array->stack.objects[2*i+0]); 5889| 0| clusters[i].num_glyphs = csi_number_get_value (&array->stack.objects[2*i+1]); 5890| 0| } 5891| 0| break; 5892| | 5893| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (5893:5): [True: 0, False: 3] ------------------ 5894| 0| string = obj->datum.string; 5895| 0| nclusters = string->len / 2; 5896| 0| if (nclusters > ARRAY_LENGTH (stack_clusters)) { ------------------ | | 145| 0|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (5896:6): [True: 0, False: 0] ------------------ 5897| 0| if (_csi_unlikely ((unsigned) nclusters >= INT_MAX / sizeof (cairo_text_cluster_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5898| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5899| 0| clusters = _csi_alloc (ctx, sizeof (cairo_text_cluster_t) * nclusters); 5900| 0| if (_csi_unlikely (clusters == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5901| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5902| 0| } else 5903| 0| clusters = stack_clusters; 5904| | 5905| 0| for (i = 0; i < nclusters; i++) { ------------------ | Branch (5905:14): [True: 0, False: 0] ------------------ 5906| 0| clusters[i].num_bytes = string->string[2*i+0]; 5907| 0| clusters[i].num_glyphs = string->string[2*i+1]; 5908| 0| } 5909| 0| break; 5910| | 5911| 3| default: ------------------ | Branch (5911:5): [True: 3, False: 0] ------------------ 5912| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5913| 3| } 5914| | 5915| 0| status = _csi_ostack_get_array (ctx, 2, &array); 5916| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5917| 0| return status; 5918| 0| status = _csi_ostack_get_string (ctx, 3, &utf8_string); 5919| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5920| 0| return status; 5921| 0| status = _csi_ostack_get_context (ctx, 4, &cr); 5922| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5923| 0| return status; 5924| | 5925| | /* count glyphs */ 5926| 0| nglyphs = 0; 5927| 0| for (i = 0; i < array->stack.len; i++) { ------------------ | Branch (5927:17): [True: 0, False: 0] ------------------ 5928| 0| obj = &array->stack.objects[i]; 5929| 0| type = csi_object_get_type (obj); 5930| 0| switch (type) { ------------------ | Branch (5930:10): [True: 0, False: 0] ------------------ 5931| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (5931:2): [True: 0, False: 0] ------------------ 5932| 0| nglyphs += obj->datum.array->stack.len; 5933| 0| break; 5934| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (5934:2): [True: 0, False: 0] ------------------ 5935| 0| nglyphs += obj->datum.string->len; 5936| 0| break; 5937| 0| } 5938| 0| } 5939| 0| if (nglyphs == 0) { ------------------ | Branch (5939:9): [True: 0, False: 0] ------------------ 5940| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5941| 0| return CSI_STATUS_SUCCESS; 5942| 0| } 5943| | 5944| 0| if (nglyphs > ARRAY_LENGTH (stack_glyphs)) { ------------------ | | 145| 0|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (5944:9): [True: 0, False: 0] ------------------ 5945| 0| if (_csi_unlikely ((unsigned) nglyphs >= INT_MAX / sizeof (cairo_glyph_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5946| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5947| | 5948| 0| glyphs = _csi_alloc (ctx, sizeof (cairo_glyph_t) * nglyphs); 5949| 0| if (_csi_unlikely (glyphs == NULL)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5950| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 5951| 0| } else 5952| 0| glyphs = stack_glyphs; 5953| | 5954| 0| nglyphs = _glyph_string (ctx, array, cairo_get_scaled_font (cr), glyphs); 5955| 0| cairo_show_text_glyphs (cr, 5956| 0| utf8_string->string, utf8_string->len, 5957| 0| glyphs, nglyphs, 5958| 0| clusters, nclusters, 5959| 0| direction); 5960| | 5961| 0| if (clusters != stack_clusters) ------------------ | Branch (5961:9): [True: 0, False: 0] ------------------ 5962| 0| _csi_free (ctx, clusters); 5963| 0| if (glyphs != stack_glyphs) ------------------ | Branch (5963:9): [True: 0, False: 0] ------------------ 5964| 0| _csi_free (ctx, glyphs); 5965| | 5966| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5967| 0| return CSI_STATUS_SUCCESS; 5968| 0|} cairo-script-operators.c:_show_page: 5632| 6|{ 5633| 6| csi_object_t *obj; 5634| 6| int type; 5635| | 5636| 6| check (1); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 5] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 5] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 5] | | ------------------ ------------------ 5637| | 5638| 5| obj = _csi_peek_ostack (ctx, 0); 5639| 5| type = csi_object_get_type (obj); 5640| 5| switch (type) { 5641| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (5641:5): [True: 0, False: 5] ------------------ 5642| 0| cairo_show_page (obj->datum.cr); 5643| 0| if (ctx->hooks.copy_page != NULL) ------------------ | Branch (5643:6): [True: 0, False: 0] ------------------ 5644| 0| ctx->hooks.copy_page (ctx->hooks.closure, obj->datum.cr); 5645| 0| break; 5646| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (5646:5): [True: 0, False: 5] ------------------ 5647| 0| cairo_surface_show_page (obj->datum.surface); 5648| | /* XXX hook? */ 5649| 0| break; 5650| 5| default: ------------------ | Branch (5650:5): [True: 5, False: 0] ------------------ 5651| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5652| 5| } 5653| | 5654| 0| return CSI_STATUS_SUCCESS; 5655| 5|} cairo-script-operators.c:_similar: 5659| 18|{ 5660| 18| csi_object_t obj; 5661| 18| long content; 5662| 18| double width, height; 5663| 18| cairo_surface_t *other; 5664| 18| csi_status_t status; 5665| | 5666| 18| check (4); ------------------ | | 93| 18|#define check(CNT) do {\ | | 94| 18| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 18|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 18| __extension__ ({ \ | | | | | | 112| 18| int _csi_boolean_var_; \ | | | | | | 113| 18| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 16] | | | | | | ------------------ | | | | | | 114| 18| _csi_boolean_var_ = 1; \ | | | | | | 115| 18| else \ | | | | | | 116| 18| _csi_boolean_var_ = 0; \ | | | | | | 117| 18| _csi_boolean_var_; \ | | | | | | 118| 18|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 16] | | | | ------------------ | | ------------------ | | 95| 18| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 18|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 16] | | ------------------ ------------------ 5667| | 5668| 16| status = _csi_ostack_get_integer (ctx, 0, &content); 5669| 16| if (_csi_unlikely (status)) ------------------ | | 120| 16|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 16| __extension__ ({ \ | | | | 112| 16| int _csi_boolean_var_; \ | | | | 113| 16| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 4, False: 12] | | | | ------------------ | | | | 114| 16| _csi_boolean_var_ = 1; \ | | | | 115| 16| else \ | | | | 116| 16| _csi_boolean_var_ = 0; \ | | | | 117| 16| _csi_boolean_var_; \ | | | | 118| 16|}) | | ------------------ | | | Branch (120:29): [True: 4, False: 12] | | ------------------ ------------------ 5670| 4| return status; 5671| 12| status = _csi_ostack_get_number (ctx, 1, &height); 5672| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 11] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 11] | | ------------------ ------------------ 5673| 1| return status; 5674| 11| status = _csi_ostack_get_number (ctx, 2, &width); 5675| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 9] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 9] | | ------------------ ------------------ 5676| 2| return status; 5677| 9| status = _csi_ostack_get_surface (ctx, 3, &other); 5678| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 9, False: 0] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 9, False: 0] | | ------------------ ------------------ 5679| 9| return status; 5680| | 5681| | /* silently fix-up a common bug when writing CS */ 5682| 0| if ((content & CAIRO_CONTENT_COLOR_ALPHA) == 0) { ------------------ | Branch (5682:9): [True: 0, False: 0] ------------------ 5683| 0| if (_csi_unlikely (content & ~CAIRO_CONTENT_COLOR_ALPHA)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 5684| 0| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5685| | 5686| 0| switch ((int) content) { 5687| 0| default: ------------------ | Branch (5687:2): [True: 0, False: 0] ------------------ 5688| 0| case CAIRO_FORMAT_ARGB32: ------------------ | Branch (5688:2): [True: 0, False: 0] ------------------ 5689| 0| content = CAIRO_CONTENT_COLOR_ALPHA; 5690| 0| break; 5691| 0| case CAIRO_FORMAT_RGB16_565: ------------------ | Branch (5691:2): [True: 0, False: 0] ------------------ 5692| 0| case CAIRO_FORMAT_RGB24: ------------------ | Branch (5692:2): [True: 0, False: 0] ------------------ 5693| 0| content = CAIRO_CONTENT_COLOR; 5694| 0| break; 5695| 0| case CAIRO_FORMAT_A8: ------------------ | Branch (5695:2): [True: 0, False: 0] ------------------ 5696| 0| case CAIRO_FORMAT_A1: ------------------ | Branch (5696:2): [True: 0, False: 0] ------------------ 5697| 0| content = CAIRO_CONTENT_ALPHA; 5698| 0| break; 5699| 0| } 5700| 0| } 5701| | 5702| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 5703| 0| obj.datum.surface = cairo_surface_create_similar (other, 5704| 0| content, width, height); 5705| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5706| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 5707| 0|} cairo-script-operators.c:_similar_image: 5711| 12|{ 5712| 12| csi_object_t obj; 5713| 12| long format; 5714| 12| double width, height; 5715| 12| cairo_surface_t *other; 5716| 12| csi_status_t status; 5717| | 5718| 12| check (4); ------------------ | | 93| 12|#define check(CNT) do {\ | | 94| 12| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 12| __extension__ ({ \ | | | | | | 112| 12| int _csi_boolean_var_; \ | | | | | | 113| 12| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 11] | | | | | | ------------------ | | | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | | | 115| 12| else \ | | | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | | | 117| 12| _csi_boolean_var_; \ | | | | | | 118| 12|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 11] | | | | ------------------ | | ------------------ | | 95| 12| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 12|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 11] | | ------------------ ------------------ 5719| | 5720| 11| status = _csi_ostack_get_number (ctx, 0, &height); 5721| 11| if (_csi_unlikely (status)) ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 11| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 8] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 8] | | ------------------ ------------------ 5722| 3| return status; 5723| 8| status = _csi_ostack_get_number (ctx, 1, &width); 5724| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 6] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 6] | | ------------------ ------------------ 5725| 2| return status; 5726| 6| status = _csi_ostack_get_integer (ctx, 2, &format); 5727| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 5728| 1| return status; 5729| 5| status = _csi_ostack_get_surface (ctx, 3, &other); 5730| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5731| 5| return status; 5732| | 5733| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 5734| 0| obj.datum.surface = cairo_surface_create_similar_image (other, 5735| 0| format, 5736| 0| width, height); 5737| 0| pop (4); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5738| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 5739| 5|} cairo-script-operators.c:_sub: 5984| 13|{ 5985| 13| csi_object_t *A; 5986| 13| csi_object_t *B; 5987| 13| csi_object_type_t type_a, type_b; 5988| | 5989| 13| check (2); ------------------ | | 93| 13|#define check(CNT) do {\ | | 94| 13| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 13|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 13| __extension__ ({ \ | | | | | | 112| 13| int _csi_boolean_var_; \ | | | | | | 113| 13| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 11] | | | | | | ------------------ | | | | | | 114| 13| _csi_boolean_var_ = 1; \ | | | | | | 115| 13| else \ | | | | | | 116| 13| _csi_boolean_var_ = 0; \ | | | | | | 117| 13| _csi_boolean_var_; \ | | | | | | 118| 13|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 11] | | | | ------------------ | | ------------------ | | 95| 13| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 13|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 11] | | ------------------ ------------------ 5990| | 5991| 11| B = _csi_peek_ostack (ctx, 0); 5992| 11| A = _csi_peek_ostack (ctx, 1); 5993| | 5994| 11| type_a = csi_object_get_type (A); 5995| 11| if (_csi_unlikely (! (type_a == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 11| __extension__ ({ \ | | | | 112| 11| int _csi_boolean_var_; \ | | | | 113| 27| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 5] | | | | | Branch (113:8): [True: 4, False: 1] | | | | ------------------ | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | 115| 11| else \ | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | 117| 11| _csi_boolean_var_; \ | | | | 118| 11|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 10] | | ------------------ ------------------ 5996| 11| type_a == CSI_OBJECT_TYPE_REAL))) 5997| 1| { 5998| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5999| 1| } 6000| | 6001| 10| type_b = csi_object_get_type (B); 6002| 10| if (_csi_unlikely (! (type_b == CSI_OBJECT_TYPE_INTEGER || ------------------ | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10| __extension__ ({ \ | | | | 112| 10| int _csi_boolean_var_; \ | | | | 113| 24| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 4] | | | | | Branch (113:8): [True: 2, False: 2] | | | | ------------------ | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | 115| 10| else \ | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | 117| 10| _csi_boolean_var_; \ | | | | 118| 10|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 8] | | ------------------ ------------------ 6003| 10| type_b == CSI_OBJECT_TYPE_REAL))) 6004| 2| { 6005| 2| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 6006| 2| } 6007| | 6008| 8| pop (2); ------------------ | | 97| 8|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6009| | 6010| 8| if (type_a == CSI_OBJECT_TYPE_REAL && ------------------ | Branch (6010:9): [True: 4, False: 4] ------------------ 6011| 4| type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (6011:2): [True: 1, False: 3] ------------------ 6012| 1| { 6013| 1| return _csi_push_ostack_real (ctx, A->datum.real - B->datum.real); 6014| | 6015| 1| } 6016| 7| else if (type_a == CSI_OBJECT_TYPE_INTEGER && ------------------ | Branch (6016:14): [True: 4, False: 3] ------------------ 6017| 4| type_b == CSI_OBJECT_TYPE_INTEGER) ------------------ | Branch (6017:7): [True: 3, False: 1] ------------------ 6018| 3| { 6019| 3| return _csi_push_ostack_integer (ctx, 6020| 3| A->datum.integer - B->datum.integer); 6021| 3| } 6022| 4| else 6023| 4| { 6024| 4| double v; 6025| | 6026| 4| if (type_a == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (6026:6): [True: 3, False: 1] ------------------ 6027| 3| v = A->datum.real; 6028| 1| else 6029| 1| v = A->datum.integer; 6030| | 6031| 4| if (type_b == CSI_OBJECT_TYPE_REAL) ------------------ | Branch (6031:6): [True: 1, False: 3] ------------------ 6032| 1| v -= B->datum.real; 6033| 3| else 6034| 3| v -= B->datum.integer; 6035| | 6036| 4| return _csi_push_ostack_real (ctx, v); 6037| 4| } 6038| 8|} cairo-script-operators.c:_subsurface: 5743| 16|{ 5744| 16| csi_object_t obj; 5745| 16| double x, y, width, height; 5746| 16| cairo_surface_t *target; 5747| 16| csi_status_t status; 5748| | 5749| 16| check (5); ------------------ | | 93| 16|#define check(CNT) do {\ | | 94| 16| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 16|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 16| __extension__ ({ \ | | | | | | 112| 16| int _csi_boolean_var_; \ | | | | | | 113| 16| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 4, False: 12] | | | | | | ------------------ | | | | | | 114| 16| _csi_boolean_var_ = 1; \ | | | | | | 115| 16| else \ | | | | | | 116| 16| _csi_boolean_var_ = 0; \ | | | | | | 117| 16| _csi_boolean_var_; \ | | | | | | 118| 16|}) | | | | ------------------ | | | | | Branch (120:29): [True: 4, False: 12] | | | | ------------------ | | ------------------ | | 95| 16| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 16|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 12] | | ------------------ ------------------ 5750| | 5751| 12| status = _csi_ostack_get_number (ctx, 0, &height); 5752| 12| if (_csi_unlikely (status)) ------------------ | | 120| 12|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 12| __extension__ ({ \ | | | | 112| 12| int _csi_boolean_var_; \ | | | | 113| 12| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 10] | | | | ------------------ | | | | 114| 12| _csi_boolean_var_ = 1; \ | | | | 115| 12| else \ | | | | 116| 12| _csi_boolean_var_ = 0; \ | | | | 117| 12| _csi_boolean_var_; \ | | | | 118| 12|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 10] | | ------------------ ------------------ 5753| 2| return status; 5754| 10| status = _csi_ostack_get_number (ctx, 1, &width); 5755| 10| if (_csi_unlikely (status)) ------------------ | | 120| 10|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 10| __extension__ ({ \ | | | | 112| 10| int _csi_boolean_var_; \ | | | | 113| 10| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 7] | | | | ------------------ | | | | 114| 10| _csi_boolean_var_ = 1; \ | | | | 115| 10| else \ | | | | 116| 10| _csi_boolean_var_ = 0; \ | | | | 117| 10| _csi_boolean_var_; \ | | | | 118| 10|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 7] | | ------------------ ------------------ 5756| 3| return status; 5757| 7| status = _csi_ostack_get_number (ctx, 2, &y); 5758| 7| if (_csi_unlikely (status)) ------------------ | | 120| 7|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7| __extension__ ({ \ | | | | 112| 7| int _csi_boolean_var_; \ | | | | 113| 7| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 6] | | | | ------------------ | | | | 114| 7| _csi_boolean_var_ = 1; \ | | | | 115| 7| else \ | | | | 116| 7| _csi_boolean_var_ = 0; \ | | | | 117| 7| _csi_boolean_var_; \ | | | | 118| 7|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 6] | | ------------------ ------------------ 5759| 1| return status; 5760| 6| status = _csi_ostack_get_number (ctx, 3, &x); 5761| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 5] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 5] | | ------------------ ------------------ 5762| 1| return status; 5763| 5| status = _csi_ostack_get_surface (ctx, 4, &target); 5764| 5| if (_csi_unlikely (status)) ------------------ | | 120| 5|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5| __extension__ ({ \ | | | | 112| 5| int _csi_boolean_var_; \ | | | | 113| 5| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 0] | | | | ------------------ | | | | 114| 5| _csi_boolean_var_ = 1; \ | | | | 115| 5| else \ | | | | 116| 5| _csi_boolean_var_ = 0; \ | | | | 117| 5| _csi_boolean_var_; \ | | | | 118| 5|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 0] | | ------------------ ------------------ 5765| 5| return status; 5766| | 5767| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 5768| 0| obj.datum.surface = cairo_surface_create_for_rectangle (target, x, y, width, height); 5769| 0| pop (5); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5770| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 5771| 5|} cairo-script-operators.c:_surface: 6042| 4|{ 6043| 4| csi_object_t obj; 6044| 4| csi_dictionary_t *dict; 6045| 4| csi_proxy_t *proxy; 6046| 4| csi_object_t key; 6047| 4| double width, height; 6048| 4| csi_surface_create_func_t hook; 6049| 4| long content; 6050| 4| cairo_surface_t *surface; 6051| 4| long uid; 6052| 4| csi_status_t status; 6053| | 6054| 4| check (1); ------------------ | | 93| 4|#define check(CNT) do {\ | | 94| 4| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 4| __extension__ ({ \ | | | | | | 112| 4| int _csi_boolean_var_; \ | | | | | | 113| 4| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 3] | | | | | | ------------------ | | | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | | | 115| 4| else \ | | | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | | | 117| 4| _csi_boolean_var_; \ | | | | | | 118| 4|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 3] | | | | ------------------ | | ------------------ | | 95| 4| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 4|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 3] | | ------------------ ------------------ 6055| | 6056| 3| status = _csi_ostack_get_dictionary (ctx, 0, &dict); 6057| 3| if (_csi_unlikely (status)) ------------------ | | 120| 3|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3| __extension__ ({ \ | | | | 112| 3| int _csi_boolean_var_; \ | | | | 113| 3| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1] | | | | ------------------ | | | | 114| 3| _csi_boolean_var_ = 1; \ | | | | 115| 3| else \ | | | | 116| 3| _csi_boolean_var_ = 0; \ | | | | 117| 3| _csi_boolean_var_; \ | | | | 118| 3|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1] | | ------------------ ------------------ 6058| 2| return status; 6059| | 6060| 1| status = _csi_dictionary_get_number (ctx, dict, "width", FALSE, &width); ------------------ | | 51| 1|#define FALSE 0 ------------------ 6061| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 6062| 1| return status; 6063| 0| status = _csi_dictionary_get_number (ctx, dict, "height", FALSE, &height); ------------------ | | 51| 0|#define FALSE 0 ------------------ 6064| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6065| 0| return status; 6066| | 6067| 0| content = CAIRO_CONTENT_COLOR_ALPHA; 6068| 0| status = _csi_dictionary_get_integer (ctx, dict, "content", TRUE, &content); ------------------ | | 55| 0|#define TRUE (!FALSE) | | ------------------ | | | | 51| 0|#define FALSE 0 | | ------------------ ------------------ 6069| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6070| 0| return status; 6071| | 6072| 0| uid = 0; 6073| 0| status = _csi_dictionary_get_integer (ctx, dict, "uid", TRUE, &uid); ------------------ | | 55| 0|#define TRUE (!FALSE) | | ------------------ | | | | 51| 0|#define FALSE 0 | | ------------------ ------------------ 6074| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6075| 0| return status; 6076| 0| if (uid == 0) { ------------------ | Branch (6076:9): [True: 0, False: 0] ------------------ 6077| 0| status = _csi_dictionary_get_integer (ctx, dict, "drawable", TRUE, &uid); ------------------ | | 55| 0|#define TRUE (!FALSE) | | ------------------ | | | | 51| 0|#define FALSE 0 | | ------------------ ------------------ 6078| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6079| 0| return status; 6080| 0| } 6081| | 6082| 0| hook = ctx->hooks.surface_create; 6083| 0| assert (hook != NULL); ------------------ | Branch (6083:5): [True: 0, False: 0] | Branch (6083:5): [True: 0, False: 0] ------------------ 6084| | 6085| 0| surface = hook (ctx->hooks.closure, content, width, height, uid); 6086| 0| if (_csi_unlikely (surface == NULL)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6087| 0| return _csi_error (CSI_STATUS_NULL_POINTER); 6088| 0| } 6089| | 6090| 0| proxy = _csi_proxy_create (ctx, surface, dict, 6091| 0| ctx->hooks.surface_destroy, 6092| 0| ctx->hooks.closure); 6093| 0| if (_csi_unlikely (proxy == NULL)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6094| 0| cairo_surface_destroy (surface); 6095| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 6096| 0| } 6097| | 6098| 0| status = cairo_surface_set_user_data (surface, 6099| 0| &_csi_proxy_key, 6100| 0| proxy, _csi_proxy_destroy); 6101| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6102| 0| _csi_proxy_destroy (proxy); 6103| 0| cairo_surface_destroy (surface); 6104| 0| return status; 6105| 0| } 6106| | 6107| 0| status = csi_name_new_static (ctx, &key, "fallback-resolution"); 6108| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6109| 0| cairo_surface_destroy (surface); 6110| 0| return status; 6111| 0| } 6112| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (6112:9): [True: 0, False: 0] ------------------ 6113| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 6114| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6115| 0| cairo_surface_destroy (surface); 6116| 0| return status; 6117| 0| } 6118| 0| if (csi_object_get_type (&obj) == CSI_OBJECT_TYPE_ARRAY) { ------------------ | Branch (6118:6): [True: 0, False: 0] ------------------ 6119| 0| csi_array_t *array = obj.datum.array; 6120| 0| if (array->stack.len == 2) { ------------------ | Branch (6120:10): [True: 0, False: 0] ------------------ 6121| 0| cairo_surface_set_fallback_resolution (surface, 6122| 0| csi_number_get_value 6123| 0| (&array->stack.objects[0]), 6124| 0| csi_number_get_value 6125| 0| (&array->stack.objects[1])); 6126| 0| } 6127| 0| } 6128| 0| } 6129| | /* initialise surface to source */ 6130| 0| status = csi_name_new_static (ctx, &key, "source"); 6131| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6132| 0| cairo_surface_destroy (surface); 6133| 0| return status; 6134| 0| } 6135| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (6135:9): [True: 0, False: 0] ------------------ 6136| 0| cairo_surface_t *image; 6137| 0| cairo_t *cr; 6138| | 6139| 0| status = _image_load_from_dictionary (ctx, dict, &image); 6140| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6141| 0| cairo_surface_destroy (surface); 6142| 0| return status; 6143| 0| } 6144| | 6145| 0| cr = cairo_create (surface); 6146| 0| cairo_set_source_surface (cr, image, 0, 0); 6147| 0| cairo_surface_destroy (image); 6148| 0| cairo_paint (cr); 6149| 0| status = cairo_status (cr); 6150| 0| cairo_destroy (cr); 6151| | 6152| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6153| 0| return status; 6154| 0| } 6155| | 6156| 0| status = csi_name_new_static (ctx, &key, "device-offset"); 6157| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6158| 0| cairo_surface_destroy (surface); 6159| 0| return status; 6160| 0| } 6161| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (6161:9): [True: 0, False: 0] ------------------ 6162| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 6163| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6164| 0| return status; 6165| | 6166| 0| if (csi_object_get_type (&obj) == CSI_OBJECT_TYPE_ARRAY) { ------------------ | Branch (6166:6): [True: 0, False: 0] ------------------ 6167| 0| csi_array_t *array = obj.datum.array; 6168| | 6169| 0| if (array->stack.len == 2) { ------------------ | Branch (6169:10): [True: 0, False: 0] ------------------ 6170| 0| cairo_surface_set_device_offset (surface, 6171| 0| csi_number_get_value 6172| 0| (&array->stack.objects[0]), 6173| 0| csi_number_get_value 6174| 0| (&array->stack.objects[1])); 6175| 0| } 6176| 0| } 6177| 0| } 6178| | 6179| 0| status = csi_name_new_static (ctx, &key, "device-scale"); 6180| 0| if (_csi_unlikely (status)) { ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6181| 0| cairo_surface_destroy (surface); 6182| 0| return status; 6183| 0| } 6184| 0| if (csi_dictionary_has (dict, key.datum.name)) { ------------------ | Branch (6184:9): [True: 0, False: 0] ------------------ 6185| 0| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 6186| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6187| 0| return status; 6188| | 6189| 0| if (csi_object_get_type (&obj) == CSI_OBJECT_TYPE_ARRAY) { ------------------ | Branch (6189:6): [True: 0, False: 0] ------------------ 6190| 0| csi_array_t *array = obj.datum.array; 6191| | 6192| 0| if (array->stack.len == 2) { ------------------ | Branch (6192:10): [True: 0, False: 0] ------------------ 6193| 0| cairo_surface_set_device_scale (surface, 6194| 0| csi_number_get_value 6195| 0| (&array->stack.objects[0]), 6196| 0| csi_number_get_value 6197| 0| (&array->stack.objects[1])); 6198| 0| } 6199| 0| } 6200| 0| } 6201| | 6202| 0| obj.type = CSI_OBJECT_TYPE_SURFACE; 6203| 0| obj.datum.surface = surface; 6204| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6205| 0| return push (&obj); ------------------ | | 98| 0|#define push(OBJ) _csi_push_ostack (ctx, (OBJ)) ------------------ 6206| 0|} cairo-script-operators.c:_csi_dictionary_get_number: 514| 1|{ 515| 1| csi_status_t status; 516| 1| csi_object_t key, obj; 517| | 518| 1| status = csi_name_new_static (ctx, &key, name); 519| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1] | | ------------------ ------------------ 520| 0| return status; 521| | 522| 1| if (optional && ! csi_dictionary_has (dict, key.datum.name)) ------------------ | Branch (522:9): [True: 0, False: 1] | Branch (522:21): [True: 0, False: 0] ------------------ 523| 0| return CSI_STATUS_SUCCESS; 524| | 525| 1| status = csi_dictionary_get (ctx, dict, key.datum.name, &obj); 526| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 527| 1| return status; 528| | 529| 0| *value = csi_number_get_value (&obj); 530| 0| return CSI_STATUS_SUCCESS; 531| 1|} cairo-script-operators.c:_stroke: 5972| 5|{ 5973| 5| return _do_cairo_op (ctx, cairo_stroke); 5974| 5|} cairo-script-operators.c:_stroke_preserve: 5978| 7|{ 5979| 7| return _do_cairo_op (ctx, cairo_stroke_preserve); 5980| 7|} cairo-script-operators.c:_text_path: 6257| 15|{ 6258| 15| csi_status_t status; 6259| 15| csi_string_t *text; 6260| 15| cairo_t *cr; 6261| | 6262| 15| check (2); ------------------ | | 93| 15|#define check(CNT) do {\ | | 94| 15| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 15| __extension__ ({ \ | | | | | | 112| 15| int _csi_boolean_var_; \ | | | | | | 113| 15| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 14] | | | | | | ------------------ | | | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | | | 115| 15| else \ | | | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | | | 117| 15| _csi_boolean_var_; \ | | | | | | 118| 15|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 14] | | | | ------------------ | | ------------------ | | 95| 15| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 15|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 14] | | ------------------ ------------------ 6263| | 6264| 14| status = _csi_ostack_get_string (ctx, 0, &text); 6265| 14| if (_csi_unlikely (status)) ------------------ | | 120| 14|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 14| __extension__ ({ \ | | | | 112| 14| int _csi_boolean_var_; \ | | | | 113| 14| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 13, False: 1] | | | | ------------------ | | | | 114| 14| _csi_boolean_var_ = 1; \ | | | | 115| 14| else \ | | | | 116| 14| _csi_boolean_var_ = 0; \ | | | | 117| 14| _csi_boolean_var_; \ | | | | 118| 14|}) | | ------------------ | | | Branch (120:29): [True: 13, False: 1] | | ------------------ ------------------ 6266| 13| return status; 6267| 1| status = _csi_ostack_get_context (ctx, 1, &cr); 6268| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 6269| 1| return status; 6270| | 6271| 0| cairo_text_path (cr, text->string); 6272| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6273| 0| return CSI_STATUS_SUCCESS; 6274| 1|} cairo-script-operators.c:_transform: 5539| 17|{ 5540| 17| csi_object_t *obj; 5541| 17| csi_status_t status; 5542| 17| cairo_matrix_t m; 5543| 17| int type; 5544| | 5545| 17| check (2); ------------------ | | 93| 17|#define check(CNT) do {\ | | 94| 17| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 17|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 17| __extension__ ({ \ | | | | | | 112| 17| int _csi_boolean_var_; \ | | | | | | 113| 17| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 15] | | | | | | ------------------ | | | | | | 114| 17| _csi_boolean_var_ = 1; \ | | | | | | 115| 17| else \ | | | | | | 116| 17| _csi_boolean_var_ = 0; \ | | | | | | 117| 17| _csi_boolean_var_; \ | | | | | | 118| 17|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 15] | | | | ------------------ | | ------------------ | | 95| 17| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 17|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 15] | | ------------------ ------------------ 5546| | 5547| 15| status = _csi_ostack_get_matrix (ctx, 0, &m); 5548| 15| if (_csi_unlikely (status)) ------------------ | | 120| 15|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15| __extension__ ({ \ | | | | 112| 15| int _csi_boolean_var_; \ | | | | 113| 15| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 13] | | | | ------------------ | | | | 114| 15| _csi_boolean_var_ = 1; \ | | | | 115| 15| else \ | | | | 116| 15| _csi_boolean_var_ = 0; \ | | | | 117| 15| _csi_boolean_var_; \ | | | | 118| 15|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 13] | | ------------------ ------------------ 5549| 2| return status; 5550| | 5551| 13| obj = _csi_peek_ostack (ctx, 1); 5552| 13| type = csi_object_get_type (obj); 5553| 13| switch (type) { 5554| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (5554:5): [True: 0, False: 13] ------------------ 5555| 0| cairo_transform (obj->datum.cr, &m); 5556| 0| break; 5557| 0| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (5557:5): [True: 0, False: 13] ------------------ 5558| 0| { 5559| 0| cairo_matrix_t ctm; 5560| 0| cairo_pattern_get_matrix (obj->datum.pattern, &ctm); 5561| 0| cairo_matrix_multiply (&ctm, &m, &ctm); 5562| 0| cairo_pattern_set_matrix (obj->datum.pattern, &ctm); 5563| 0| } 5564| 0| break; 5565| 12| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (5565:5): [True: 12, False: 1] ------------------ 5566| 12| cairo_matrix_multiply (&obj->datum.matrix->matrix, 5567| 12| &m, 5568| 12| &obj->datum.matrix->matrix); 5569| 12| break; 5570| 1| default: ------------------ | Branch (5570:5): [True: 1, False: 12] ------------------ 5571| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5572| 13| } 5573| | 5574| 12| pop (1); ------------------ | | 97| 12|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5575| 12| return CSI_STATUS_SUCCESS; 5576| 13|} cairo-script-operators.c:_translate: 5580| 11|{ 5581| 11| csi_object_t *obj; 5582| 11| csi_status_t status; 5583| 11| double x, y; 5584| 11| int type; 5585| | 5586| 11| check (3); ------------------ | | 93| 11|#define check(CNT) do {\ | | 94| 11| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 11|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 11| __extension__ ({ \ | | | | | | 112| 11| int _csi_boolean_var_; \ | | | | | | 113| 11| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 9] | | | | | | ------------------ | | | | | | 114| 11| _csi_boolean_var_ = 1; \ | | | | | | 115| 11| else \ | | | | | | 116| 11| _csi_boolean_var_ = 0; \ | | | | | | 117| 11| _csi_boolean_var_; \ | | | | | | 118| 11|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 9] | | | | ------------------ | | ------------------ | | 95| 11| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 11|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 9] | | ------------------ ------------------ 5587| | 5588| 9| status = _csi_ostack_get_number (ctx, 0, &y); 5589| 9| if (_csi_unlikely (status)) ------------------ | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 9| __extension__ ({ \ | | | | 112| 9| int _csi_boolean_var_; \ | | | | 113| 9| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 8] | | | | ------------------ | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | 115| 9| else \ | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | 117| 9| _csi_boolean_var_; \ | | | | 118| 9|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 8] | | ------------------ ------------------ 5590| 1| return status; 5591| 8| status = _csi_ostack_get_number (ctx, 1, &x); 5592| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 7] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 7] | | ------------------ ------------------ 5593| 1| return status; 5594| | 5595| 7| obj = _csi_peek_ostack (ctx, 2); 5596| 7| type = csi_object_get_type (obj); 5597| 7| switch (type) { 5598| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (5598:5): [True: 0, False: 7] ------------------ 5599| 0| cairo_translate (obj->datum.cr, x, y); 5600| 0| break; 5601| | 5602| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (5602:5): [True: 1, False: 6] ------------------ 5603| 1| { 5604| 1| cairo_matrix_t ctm; 5605| 1| cairo_pattern_get_matrix (obj->datum.pattern, &ctm); 5606| 1| cairo_matrix_translate (&ctm, x, y); 5607| 1| cairo_pattern_set_matrix (obj->datum.pattern, &ctm); 5608| 1| } 5609| 1| break; 5610| | 5611| | 5612| 0| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (5612:5): [True: 0, False: 7] ------------------ 5613| 0| cairo_matrix_translate (&obj->datum.matrix->matrix, x, y); 5614| 0| break; 5615| | 5616| 6| default: ------------------ | Branch (5616:5): [True: 6, False: 1] ------------------ 5617| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 5618| 7| } 5619| | 5620| 1| pop (2); ------------------ | | 97| 1|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 5621| 1| return CSI_STATUS_SUCCESS; 5622| 7|} cairo-script-operators.c:_true: 5626| 206|{ 5627| 206| return _csi_push_ostack_boolean (ctx, TRUE); ------------------ | | 55| 206|#define TRUE (!FALSE) | | ------------------ | | | | 51| 206|#define FALSE 0 | | ------------------ ------------------ 5628| 206|} cairo-script-operators.c:_undef: 6278| 9|{ 6279| 9| csi_name_t name = 0; /* silence the compiler */ 6280| 9| csi_status_t status; 6281| | 6282| 9| check (1); ------------------ | | 93| 9|#define check(CNT) do {\ | | 94| 9| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 9|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 9| __extension__ ({ \ | | | | | | 112| 9| int _csi_boolean_var_; \ | | | | | | 113| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 1, False: 8] | | | | | | ------------------ | | | | | | 114| 9| _csi_boolean_var_ = 1; \ | | | | | | 115| 9| else \ | | | | | | 116| 9| _csi_boolean_var_ = 0; \ | | | | | | 117| 9| _csi_boolean_var_; \ | | | | | | 118| 9|}) | | | | ------------------ | | | | | Branch (120:29): [True: 1, False: 8] | | | | ------------------ | | ------------------ | | 95| 9| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 9|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 8] | | ------------------ ------------------ 6283| | 6284| 8| status = _csi_ostack_get_name (ctx, 0, &name); 6285| 8| if (_csi_unlikely (status)) ------------------ | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8| __extension__ ({ \ | | | | 112| 8| int _csi_boolean_var_; \ | | | | 113| 8| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 7, False: 1] | | | | ------------------ | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | 115| 8| else \ | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | 117| 8| _csi_boolean_var_; \ | | | | 118| 8|}) | | ------------------ | | | Branch (120:29): [True: 7, False: 1] | | ------------------ ------------------ 6286| 7| return status; 6287| | 6288| 1| status = _csi_name_undefine (ctx, name); 6289| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 6290| 1| return status; 6291| | 6292| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6293| 0| return CSI_STATUS_SUCCESS; 6294| 1|} cairo-script-operators.c:_unmap_image: 3814| 8|{ 3815| 8| cairo_surface_t *surface, *image; 3816| 8| csi_status_t status; 3817| | 3818| 8| check (2); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 6] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 6] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 3819| | 3820| 6| status = _csi_ostack_get_surface (ctx, 0, &image); 3821| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 6, False: 0] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 6, False: 0] | | ------------------ ------------------ 3822| 6| return status; 3823| 0| status = _csi_ostack_get_surface (ctx, 1, &surface); 3824| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 3825| 0| return status; 3826| | 3827| 0| cairo_surface_unmap_image (surface, image); 3828| | 3829| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 3830| 0| return CSI_STATUS_SUCCESS; 3831| 0|} cairo-script-operators.c:_unset: 6298| 8|{ 6299| 8| csi_object_t *dst; 6300| 8| csi_name_t name = 0; /* silence the compiler */ 6301| 8| csi_status_t status; 6302| 8| int type; 6303| | 6304| 8| check (2); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 6] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 6] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 6305| | 6306| 6| status = _csi_ostack_get_name (ctx, 0, &name); 6307| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 1] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 1] | | ------------------ ------------------ 6308| 5| return status; 6309| | 6310| 1| dst = _csi_peek_ostack (ctx, 1); 6311| 1| type = csi_object_get_type (dst); 6312| 1| switch (type) { 6313| 0| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (6313:5): [True: 0, False: 1] ------------------ 6314| 0| csi_dictionary_remove (ctx, dst->datum.dictionary, name); 6315| 0| break; 6316| 0| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (6316:5): [True: 0, False: 1] ------------------ 6317| 0| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (6317:5): [True: 0, False: 1] ------------------ 6318| 1| default: ------------------ | Branch (6318:5): [True: 1, False: 0] ------------------ 6319| 1| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 6320| 1| } 6321| | 6322| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6323| 0| return CSI_STATUS_SUCCESS; 6324| 1|} cairo-script-operators.c:_write_to_png: 6328| 6|{ 6329| 6| csi_status_t status; 6330| 6| csi_string_t *filename; 6331| 6| cairo_surface_t *surface; 6332| | 6333| 6| check (2); ------------------ | | 93| 6|#define check(CNT) do {\ | | 94| 6| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 6| __extension__ ({ \ | | | | | | 112| 6| int _csi_boolean_var_; \ | | | | | | 113| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 4] | | | | | | ------------------ | | | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | | | 115| 6| else \ | | | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | | | 117| 6| _csi_boolean_var_; \ | | | | | | 118| 6|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 4] | | | | ------------------ | | ------------------ | | 95| 6| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 6|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 4] | | ------------------ ------------------ 6334| | 6335| 4| status = _csi_ostack_get_string (ctx, 0, &filename); 6336| 4| if (_csi_unlikely (status)) ------------------ | | 120| 4|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4| __extension__ ({ \ | | | | 112| 4| int _csi_boolean_var_; \ | | | | 113| 4| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 2] | | | | ------------------ | | | | 114| 4| _csi_boolean_var_ = 1; \ | | | | 115| 4| else \ | | | | 116| 4| _csi_boolean_var_ = 0; \ | | | | 117| 4| _csi_boolean_var_; \ | | | | 118| 4|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 2] | | ------------------ ------------------ 6337| 2| return status; 6338| 2| status = _csi_ostack_get_surface (ctx, 1, &surface); 6339| 2| if (_csi_unlikely (status)) ------------------ | | 120| 2|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2| __extension__ ({ \ | | | | 112| 2| int _csi_boolean_var_; \ | | | | 113| 2| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 0] | | | | ------------------ | | | | 114| 2| _csi_boolean_var_ = 1; \ | | | | 115| 2| else \ | | | | 116| 2| _csi_boolean_var_ = 0; \ | | | | 117| 2| _csi_boolean_var_; \ | | | | 118| 2|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 0] | | ------------------ ------------------ 6340| 2| return status; 6341| | 6342| 0|#if CAIRO_HAS_PNG_FUNCTIONS 6343| 0| status = cairo_surface_write_to_png (surface, filename->string); 6344| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6345| 0| return status; 6346| |#else 6347| | return CAIRO_STATUS_WRITE_ERROR; 6348| |#endif 6349| | 6350| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6351| 0| return CSI_STATUS_SUCCESS; 6352| 0|} cairo-script-operators.c:_write_to_script: 6356| 8|{ 6357| 8| csi_status_t status; 6358| 8| csi_string_t *filename; 6359| 8| cairo_surface_t *record; 6360| | 6361| 8| check (2); ------------------ | | 93| 8|#define check(CNT) do {\ | | 94| 8| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 8|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 8| __extension__ ({ \ | | | | | | 112| 8| int _csi_boolean_var_; \ | | | | | | 113| 8| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 6] | | | | | | ------------------ | | | | | | 114| 8| _csi_boolean_var_ = 1; \ | | | | | | 115| 8| else \ | | | | | | 116| 8| _csi_boolean_var_ = 0; \ | | | | | | 117| 8| _csi_boolean_var_; \ | | | | | | 118| 8|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 6] | | | | ------------------ | | ------------------ | | 95| 8| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 8|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 6] | | ------------------ ------------------ 6362| | 6363| 6| status = _csi_ostack_get_string (ctx, 0, &filename); 6364| 6| if (_csi_unlikely (status)) ------------------ | | 120| 6|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 6| __extension__ ({ \ | | | | 112| 6| int _csi_boolean_var_; \ | | | | 113| 6| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 1] | | | | ------------------ | | | | 114| 6| _csi_boolean_var_ = 1; \ | | | | 115| 6| else \ | | | | 116| 6| _csi_boolean_var_ = 0; \ | | | | 117| 6| _csi_boolean_var_; \ | | | | 118| 6|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 1] | | ------------------ ------------------ 6365| 5| return status; 6366| 1| status = _csi_ostack_get_surface (ctx, 1, &record); 6367| 1| if (_csi_unlikely (status)) ------------------ | | 120| 1|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1| __extension__ ({ \ | | | | 112| 1| int _csi_boolean_var_; \ | | | | 113| 1| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 0] | | | | ------------------ | | | | 114| 1| _csi_boolean_var_ = 1; \ | | | | 115| 1| else \ | | | | 116| 1| _csi_boolean_var_ = 0; \ | | | | 117| 1| _csi_boolean_var_; \ | | | | 118| 1|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 0] | | ------------------ ------------------ 6368| 1| return status; 6369| | 6370| 0| if (cairo_surface_get_type (record) != CAIRO_SURFACE_TYPE_RECORDING) ------------------ | Branch (6370:9): [True: 0, False: 0] ------------------ 6371| 0| return CAIRO_STATUS_SURFACE_TYPE_MISMATCH; 6372| | 6373| 0|#if CAIRO_HAS_SCRIPT_SURFACE 6374| 0| { 6375| 0| cairo_device_t *script; 6376| | 6377| 0| script = cairo_script_create (filename->string); 6378| 0| status = cairo_script_from_recording_surface (script, record); 6379| 0| cairo_device_destroy (script); 6380| 0| if (_csi_unlikely (status)) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 6381| 0| return status; 6382| 0| } 6383| |#else 6384| | return CAIRO_STATUS_WRITE_ERROR; 6385| |#endif 6386| | 6387| 0| pop (1); ------------------ | | 97| 0|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6388| 0| return CSI_STATUS_SUCCESS; 6389| 0|} cairo-script-operators.c:_xor: 6393| 19.0k|{ 6394| 19.0k| csi_object_t *a, *b; 6395| 19.0k| int type; 6396| | 6397| 19.0k| check (2); ------------------ | | 93| 19.0k|#define check(CNT) do {\ | | 94| 19.0k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 19.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 19.0k| __extension__ ({ \ | | | | | | 112| 19.0k| int _csi_boolean_var_; \ | | | | | | 113| 19.0k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 2, False: 19.0k] | | | | | | ------------------ | | | | | | 114| 19.0k| _csi_boolean_var_ = 1; \ | | | | | | 115| 19.0k| else \ | | | | | | 116| 19.0k| _csi_boolean_var_ = 0; \ | | | | | | 117| 19.0k| _csi_boolean_var_; \ | | | | | | 118| 19.0k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 2, False: 19.0k] | | | | ------------------ | | ------------------ | | 95| 19.0k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 19.0k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 19.0k] | | ------------------ ------------------ 6398| | 6399| 19.0k| a = _csi_peek_ostack (ctx, 0); 6400| 19.0k| b = _csi_peek_ostack (ctx, 1); 6401| 19.0k| if (_csi_unlikely (csi_object_get_type (a) != csi_object_get_type (b))) ------------------ | | 120| 19.0k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 19.0k| __extension__ ({ \ | | | | 112| 19.0k| int _csi_boolean_var_; \ | | | | 113| 19.0k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 19.0k] | | | | ------------------ | | | | 114| 19.0k| _csi_boolean_var_ = 1; \ | | | | 115| 19.0k| else \ | | | | 116| 19.0k| _csi_boolean_var_ = 0; \ | | | | 117| 19.0k| _csi_boolean_var_; \ | | | | 118| 19.0k|}) | | ------------------ | | | Branch (120:29): [True: 5, False: 19.0k] | | ------------------ ------------------ 6402| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 6403| | 6404| 19.0k| pop (2); ------------------ | | 97| 19.0k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6405| 19.0k| type = csi_object_get_type (a); 6406| 19.0k| switch (type) { 6407| 15| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (6407:5): [True: 15, False: 19.0k] ------------------ 6408| 15| return _csi_push_ostack_integer (ctx, 6409| 15| a->datum.integer ^ b->datum.integer); 6410| 19.0k| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (6410:5): [True: 19.0k, False: 20] ------------------ 6411| 19.0k| return _csi_push_ostack_boolean (ctx, 6412| 19.0k| a->datum.boolean ^ b->datum.boolean); 6413| 5| default: ------------------ | Branch (6413:5): [True: 5, False: 19.0k] ------------------ 6414| 5| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 6415| 19.0k| } 6416| 19.0k|} cairo-script-operators.c:_debug_print: 6420| 2.22k|{ 6421| 2.22k| csi_object_t *obj; 6422| | 6423| 2.22k| check (1); ------------------ | | 93| 2.22k|#define check(CNT) do {\ | | 94| 2.22k| if (_csi_unlikely (! _csi_check_ostack (ctx, (CNT)))) \ | | ------------------ | | | | 120| 2.22k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 111| 2.22k| __extension__ ({ \ | | | | | | 112| 2.22k| int _csi_boolean_var_; \ | | | | | | 113| 2.22k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (113:8): [True: 6, False: 2.22k] | | | | | | ------------------ | | | | | | 114| 2.22k| _csi_boolean_var_ = 1; \ | | | | | | 115| 2.22k| else \ | | | | | | 116| 2.22k| _csi_boolean_var_ = 0; \ | | | | | | 117| 2.22k| _csi_boolean_var_; \ | | | | | | 118| 2.22k|}) | | | | ------------------ | | | | | Branch (120:29): [True: 6, False: 2.22k] | | | | ------------------ | | ------------------ | | 95| 2.22k| return _csi_error (CSI_STATUS_INVALID_SCRIPT); \ | | 96| 2.22k|} while (0) | | ------------------ | | | Branch (96:10): [Folded, False: 2.22k] | | ------------------ ------------------ 6424| 2.22k| obj = _csi_peek_ostack (ctx, 0); 6425| 2.22k| switch (csi_object_get_type (obj)) { ------------------ | Branch (6425:13): [True: 2.22k, False: 0] ------------------ 6426| 0| case CSI_OBJECT_TYPE_NULL: ------------------ | Branch (6426:5): [True: 0, False: 2.22k] ------------------ 6427| 0| fprintf (stderr, "NULL\n"); 6428| 0| break; 6429| | 6430| | /* atomics */ 6431| 2| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (6431:5): [True: 2, False: 2.21k] ------------------ 6432| 2| fprintf (stderr, "boolean: %s\n", 6433| 2| obj->datum.boolean ? "true" : "false"); ------------------ | Branch (6433:4): [True: 1, False: 1] ------------------ 6434| 2| break; 6435| 51| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (6435:5): [True: 51, False: 2.16k] ------------------ 6436| 51| fprintf (stderr, "integer: %ld\n", obj->datum.integer); 6437| 51| break; 6438| 203| case CSI_OBJECT_TYPE_MARK: ------------------ | Branch (6438:5): [True: 203, False: 2.01k] ------------------ 6439| 203| fprintf (stderr, "mark\n"); 6440| 203| break; 6441| 11| case CSI_OBJECT_TYPE_NAME: ------------------ | Branch (6441:5): [True: 11, False: 2.20k] ------------------ 6442| 11| fprintf (stderr, "name: %s\n", (char *) obj->datum.name); 6443| 11| break; 6444| 1| case CSI_OBJECT_TYPE_OPERATOR: ------------------ | Branch (6444:5): [True: 1, False: 2.21k] ------------------ 6445| 1| fprintf (stderr, "operator: %p\n", obj->datum.ptr); 6446| 1| break; 6447| 36| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (6447:5): [True: 36, False: 2.18k] ------------------ 6448| 36| fprintf (stderr, "real: %g\n", obj->datum.real); 6449| 36| break; 6450| | 6451| | /* compound */ 6452| 3| case CSI_OBJECT_TYPE_ARRAY: ------------------ | Branch (6452:5): [True: 3, False: 2.21k] ------------------ 6453| 3| fprintf (stderr, "array\n"); 6454| 3| break; 6455| 1| case CSI_OBJECT_TYPE_DICTIONARY: ------------------ | Branch (6455:5): [True: 1, False: 2.21k] ------------------ 6456| 1| fprintf (stderr, "dictionary\n"); 6457| 1| break; 6458| 0| case CSI_OBJECT_TYPE_FILE: ------------------ | Branch (6458:5): [True: 0, False: 2.22k] ------------------ 6459| 0| fprintf (stderr, "file\n"); 6460| 0| break; 6461| 0| case CSI_OBJECT_TYPE_MATRIX: ------------------ | Branch (6461:5): [True: 0, False: 2.22k] ------------------ 6462| 0| fprintf (stderr, "matrix: [%g %g %g %g %g %g]\n", 6463| 0| obj->datum.matrix->matrix.xx, 6464| 0| obj->datum.matrix->matrix.yx, 6465| 0| obj->datum.matrix->matrix.xy, 6466| 0| obj->datum.matrix->matrix.yy, 6467| 0| obj->datum.matrix->matrix.x0, 6468| 0| obj->datum.matrix->matrix.y0); 6469| 0| break; 6470| 1.91k| case CSI_OBJECT_TYPE_STRING: ------------------ | Branch (6470:5): [True: 1.91k, False: 309] ------------------ 6471| 1.91k| fprintf (stderr, "string: %s\n", obj->datum.string->string); 6472| 1.91k| break; 6473| | 6474| | /* cairo */ 6475| 0| case CSI_OBJECT_TYPE_CONTEXT: ------------------ | Branch (6475:5): [True: 0, False: 2.22k] ------------------ 6476| 0| fprintf (stderr, "context\n"); 6477| 0| break; 6478| 0| case CSI_OBJECT_TYPE_FONT: ------------------ | Branch (6478:5): [True: 0, False: 2.22k] ------------------ 6479| 0| fprintf (stderr, "font\n"); 6480| 0| break; 6481| 1| case CSI_OBJECT_TYPE_PATTERN: ------------------ | Branch (6481:5): [True: 1, False: 2.21k] ------------------ 6482| 1| fprintf (stderr, "pattern\n"); 6483| 1| break; 6484| 0| case CSI_OBJECT_TYPE_SCALED_FONT: ------------------ | Branch (6484:5): [True: 0, False: 2.22k] ------------------ 6485| 0| fprintf (stderr, "scaled-font\n"); 6486| 0| break; 6487| 0| case CSI_OBJECT_TYPE_SURFACE: ------------------ | Branch (6487:5): [True: 0, False: 2.22k] ------------------ 6488| 0| fprintf (stderr, "surface\n"); 6489| 0| break; 6490| 2.22k| } 6491| 2.22k| pop (1); ------------------ | | 97| 2.22k|#define pop(CNT) _csi_pop_ostack (ctx, (CNT)) ------------------ 6492| 2.22k| return CSI_STATUS_SUCCESS; 6493| 2.22k|} cairo-script-interpreter.c:csi_integer_new: 690| 1.16M|{ 691| 1.16M| obj->type = CSI_OBJECT_TYPE_INTEGER; 692| 1.16M| obj->datum.integer = v; 693| 1.16M|} cairo-script-interpreter.c:csi_operator_new: 733| 1.00M|{ 734| 1.00M| obj->type = CSI_OBJECT_TYPE_OPERATOR | CSI_OBJECT_ATTR_EXECUTABLE; 735| 1.00M| obj->datum.op = op; 736| 1.00M|} cairo-script-interpreter.c:csi_real_new: 741| 20.5k|{ 742| 20.5k| obj->type = CSI_OBJECT_TYPE_REAL; 743| 20.5k| obj->datum.real = v; 744| 20.5k|} cairo-script-objects.c:_csi_push_ostack_copy: 917| 1|{ 918| 1| return _csi_stack_push (ctx, &ctx->ostack, csi_object_reference (obj)); 919| 1|} cairo-script-objects.c:csi_object_get_type: 855| 554k|{ 856| 554k| return obj->type & CSI_OBJECT_TYPE_MASK; ------------------ | | 253| 554k|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 554k|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 554k| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ 857| 554k|} cairo-script-operators.c:_csi_push_ostack_mark: 945| 3.04M|{ 946| 3.04M| csi_object_t obj; 947| 3.04M| obj.type = CSI_OBJECT_TYPE_MARK; 948| 3.04M| return _csi_stack_push (ctx, &ctx->ostack, &obj); 949| 3.04M|} cairo-script-operators.c:_csi_check_ostack: 897| 1.03M|{ 898| 1.03M| return ctx->ostack.len >= count; 899| 1.03M|} cairo-script-operators.c:_csi_peek_ostack: 903| 1.72M|{ 904| 1.72M| return &ctx->ostack.objects[ctx->ostack.len - i -1]; 905| 1.72M|} cairo-script-operators.c:csi_object_get_type: 855| 1.01M|{ 856| 1.01M| return obj->type & CSI_OBJECT_TYPE_MASK; ------------------ | | 253| 1.01M|#define CSI_OBJECT_TYPE_MASK (~CSI_OBJECT_ATTR_MASK) | | ------------------ | | | | 251| 1.01M|#define CSI_OBJECT_ATTR_MASK (CSI_OBJECT_ATTR_EXECUTABLE | \ | | | | 252| 1.01M| CSI_OBJECT_ATTR_WRITABLE) | | ------------------ ------------------ 857| 1.01M|} cairo-script-operators.c:_csi_pop_ostack: 909| 333k|{ 910| 333k| do 911| 760k| csi_object_free (ctx, &ctx->ostack.objects[--ctx->ostack.len]); 912| 760k| while (--count); ------------------ | Branch (912:12): [True: 427k, False: 333k] ------------------ 913| 333k|} cairo-script-operators.c:_csi_push_ostack: 923| 551k|{ 924| 551k| return _csi_stack_push (ctx, &ctx->ostack, obj); 925| 551k|} cairo-script-operators.c:_csi_push_ostack_real: 959| 3.69k|{ 960| 3.69k| csi_object_t obj; 961| 3.69k| obj.type = CSI_OBJECT_TYPE_REAL; 962| 3.69k| obj.datum.real = v; 963| 3.69k| return _csi_stack_push (ctx, &ctx->ostack, &obj); 964| 3.69k|} cairo-script-operators.c:_csi_push_ostack_integer: 937| 2.24k|{ 938| 2.24k| csi_object_t obj; 939| 2.24k| obj.type = CSI_OBJECT_TYPE_INTEGER; 940| 2.24k| obj.datum.integer = v; 941| 2.24k| return _csi_stack_push (ctx, &ctx->ostack, &obj); 942| 2.24k|} cairo-script-operators.c:_csi_push_ostack_boolean: 929| 352k|{ 930| 352k| csi_object_t obj; 931| 352k| obj.type = CSI_OBJECT_TYPE_BOOLEAN; 932| 352k| obj.datum.boolean = v; 933| 352k| return _csi_stack_push (ctx, &ctx->ostack, &obj); 934| 352k|} cairo-script-operators.c:csi_object_is_procedure: 861| 14|{ 862| 14| return obj->type == (CSI_OBJECT_TYPE_ARRAY | CSI_OBJECT_ATTR_EXECUTABLE); 863| 14|} cairo-script-operators.c:_csi_push_ostack_copy: 917| 7.75k|{ 918| 7.75k| return _csi_stack_push (ctx, &ctx->ostack, csi_object_reference (obj)); 919| 7.75k|} cairo-script-operators.c:csi_object_is_number: 867| 1.16k|{ 868| 1.16k| int type = csi_object_get_type (obj); 869| 1.16k| switch (type) { 870| 8| case CSI_OBJECT_TYPE_BOOLEAN: ------------------ | Branch (870:5): [True: 8, False: 1.15k] ------------------ 871| 1.16k| case CSI_OBJECT_TYPE_INTEGER: ------------------ | Branch (871:5): [True: 1.15k, False: 12] ------------------ 872| 1.16k| case CSI_OBJECT_TYPE_REAL: ------------------ | Branch (872:5): [True: 1, False: 1.16k] ------------------ 873| 1.16k| return 1; 874| 3| default: ------------------ | Branch (874:5): [True: 3, False: 1.16k] ------------------ 875| 3| return 0; 876| 1.16k| } 877| 1.16k|} cairo-script-operators.c:_csi_push_ostack_null: 952| 21.2k|{ 953| 21.2k| csi_object_t obj; 954| 21.2k| obj.type = CSI_OBJECT_TYPE_NULL; 955| 21.2k| return _csi_stack_push (ctx, &ctx->ostack, &obj); 956| 21.2k|} cairo-script-scanner.c:_csi_push_ostack: 923| 1.19M|{ 924| 1.19M| return _csi_stack_push (ctx, &ctx->ostack, obj); 925| 1.19M|} cairo-script-scanner.c:csi_integer_new: 690| 398k|{ 691| 398k| obj->type = CSI_OBJECT_TYPE_INTEGER; 692| 398k| obj->datum.integer = v; 693| 398k|} cairo-script-scanner.c:csi_real_new: 741| 400k|{ 742| 400k| obj->type = CSI_OBJECT_TYPE_REAL; 743| 400k| obj->datum.real = v; 744| 400k|} cairo-script-scanner.c:csi_operator_new: 733| 525k|{ 734| 525k| obj->type = CSI_OBJECT_TYPE_OPERATOR | CSI_OBJECT_ATTR_EXECUTABLE; 735| 525k| obj->datum.op = op; 736| 525k|} _csi_parse_number: 256| 4.53M|{ 257| 4.53M| int radix = 0; 258| 4.53M| long long mantissa = 0; 259| 4.53M| int exponent = 0; 260| 4.53M| int sign = 1; 261| 4.53M| int decimal = -1; 262| 4.53M| int exponent_sign = 0; 263| 4.53M| const char * const end = s + len; 264| | 265| 4.53M| switch (*s) { 266| 40.3k| case '0': ------------------ | Branch (266:5): [True: 40.3k, False: 4.49M] ------------------ 267| 52.6k| case '1': ------------------ | Branch (267:5): [True: 12.2k, False: 4.52M] ------------------ 268| 56.9k| case '2': ------------------ | Branch (268:5): [True: 4.33k, False: 4.52M] ------------------ 269| 69.3k| case '3': ------------------ | Branch (269:5): [True: 12.3k, False: 4.52M] ------------------ 270| 72.0k| case '4': ------------------ | Branch (270:5): [True: 2.65k, False: 4.53M] ------------------ 271| 78.6k| case '5': ------------------ | Branch (271:5): [True: 6.56k, False: 4.52M] ------------------ 272| 88.1k| case '6': ------------------ | Branch (272:5): [True: 9.57k, False: 4.52M] ------------------ 273| 119k| case '7': ------------------ | Branch (273:5): [True: 31.7k, False: 4.50M] ------------------ 274| 121k| case '8': ------------------ | Branch (274:5): [True: 1.24k, False: 4.53M] ------------------ 275| 121k| case '9': ------------------ | Branch (275:5): [True: 537, False: 4.53M] ------------------ 276| 121k| mantissa = *s - '0'; 277| 122k| case '+': ------------------ | Branch (277:5): [True: 861, False: 4.53M] ------------------ 278| 122k| break; 279| 2.91k| case '-': ------------------ | Branch (279:5): [True: 2.91k, False: 4.53M] ------------------ 280| 2.91k| sign = -1; 281| 2.91k| break; 282| 100k| case '.': ------------------ | Branch (282:5): [True: 100k, False: 4.43M] ------------------ 283| 100k| decimal = 0; 284| 100k| break; 285| 4.30M| default: ------------------ | Branch (285:5): [True: 4.30M, False: 225k] ------------------ 286| 4.30M| return FALSE; ------------------ | | 51| 4.30M|#define FALSE 0 ------------------ 287| 4.53M| } 288| | 289| 8.22M| while (++s < end) { ------------------ | Branch (289:12): [True: 8.00M, False: 218k] ------------------ 290| 8.00M| if (*s < '0') { ------------------ | Branch (290:6): [True: 6.08k, False: 8.00M] ------------------ 291| 6.08k| if (*s == '.') { ------------------ | Branch (291:10): [True: 1.64k, False: 4.44k] ------------------ 292| 1.64k| if (_csi_unlikely (radix)) ------------------ | | 120| 1.64k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.64k| __extension__ ({ \ | | | | 112| 1.64k| int _csi_boolean_var_; \ | | | | 113| 1.64k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 1.64k] | | | | ------------------ | | | | 114| 1.64k| _csi_boolean_var_ = 1; \ | | | | 115| 1.64k| else \ | | | | 116| 1.64k| _csi_boolean_var_ = 0; \ | | | | 117| 1.64k| _csi_boolean_var_; \ | | | | 118| 1.64k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 1.64k] | | ------------------ ------------------ 293| 2| return FALSE; ------------------ | | 51| 2|#define FALSE 0 ------------------ 294| 1.64k| if (_csi_unlikely (decimal != -1)) ------------------ | | 120| 1.64k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.64k| __extension__ ({ \ | | | | 112| 1.64k| int _csi_boolean_var_; \ | | | | 113| 1.64k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 423, False: 1.21k] | | | | ------------------ | | | | 114| 1.64k| _csi_boolean_var_ = 1; \ | | | | 115| 1.64k| else \ | | | | 116| 1.64k| _csi_boolean_var_ = 0; \ | | | | 117| 1.64k| _csi_boolean_var_; \ | | | | 118| 1.64k|}) | | ------------------ | | | Branch (120:29): [True: 423, False: 1.21k] | | ------------------ ------------------ 295| 423| return FALSE; ------------------ | | 51| 423|#define FALSE 0 ------------------ 296| 1.21k| if (_csi_unlikely (exponent_sign)) ------------------ | | 120| 1.21k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.21k| __extension__ ({ \ | | | | 112| 1.21k| int _csi_boolean_var_; \ | | | | 113| 1.21k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 69, False: 1.14k] | | | | ------------------ | | | | 114| 1.21k| _csi_boolean_var_ = 1; \ | | | | 115| 1.21k| else \ | | | | 116| 1.21k| _csi_boolean_var_ = 0; \ | | | | 117| 1.21k| _csi_boolean_var_; \ | | | | 118| 1.21k|}) | | ------------------ | | | Branch (120:29): [True: 69, False: 1.14k] | | ------------------ ------------------ 297| 69| return FALSE; ------------------ | | 51| 69|#define FALSE 0 ------------------ 298| | 299| 1.14k| decimal = 0; 300| 4.44k| } else if (*s == '!') { ------------------ | Branch (300:17): [True: 1.60k, False: 2.83k] ------------------ 301| 1.60k| if (_csi_unlikely (radix)) ------------------ | | 120| 1.60k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.60k| __extension__ ({ \ | | | | 112| 1.60k| int _csi_boolean_var_; \ | | | | 113| 1.60k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 10, False: 1.59k] | | | | ------------------ | | | | 114| 1.60k| _csi_boolean_var_ = 1; \ | | | | 115| 1.60k| else \ | | | | 116| 1.60k| _csi_boolean_var_ = 0; \ | | | | 117| 1.60k| _csi_boolean_var_; \ | | | | 118| 1.60k|}) | | ------------------ | | | Branch (120:29): [True: 10, False: 1.59k] | | ------------------ ------------------ 302| 10| return FALSE; ------------------ | | 51| 10|#define FALSE 0 ------------------ 303| 1.59k| if (_csi_unlikely (decimal != -1)) ------------------ | | 120| 1.59k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.59k| __extension__ ({ \ | | | | 112| 1.59k| int _csi_boolean_var_; \ | | | | 113| 1.59k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 104, False: 1.49k] | | | | ------------------ | | | | 114| 1.59k| _csi_boolean_var_ = 1; \ | | | | 115| 1.59k| else \ | | | | 116| 1.59k| _csi_boolean_var_ = 0; \ | | | | 117| 1.59k| _csi_boolean_var_; \ | | | | 118| 1.59k|}) | | ------------------ | | | Branch (120:29): [True: 104, False: 1.49k] | | ------------------ ------------------ 304| 104| return FALSE; ------------------ | | 51| 104|#define FALSE 0 ------------------ 305| 1.49k| if (_csi_unlikely (exponent_sign)) ------------------ | | 120| 1.49k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.49k| __extension__ ({ \ | | | | 112| 1.49k| int _csi_boolean_var_; \ | | | | 113| 1.49k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 9, False: 1.48k] | | | | ------------------ | | | | 114| 1.49k| _csi_boolean_var_ = 1; \ | | | | 115| 1.49k| else \ | | | | 116| 1.49k| _csi_boolean_var_ = 0; \ | | | | 117| 1.49k| _csi_boolean_var_; \ | | | | 118| 1.49k|}) | | ------------------ | | | Branch (120:29): [True: 9, False: 1.48k] | | ------------------ ------------------ 306| 9| return FALSE; ------------------ | | 51| 9|#define FALSE 0 ------------------ 307| | 308| 1.48k| radix = mantissa; 309| 1.48k| mantissa = 0; 310| | 311| 1.48k| if (_csi_unlikely (radix < 2 || radix > 36)) ------------------ | | 120| 1.48k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.48k| __extension__ ({ \ | | | | 112| 1.48k| int _csi_boolean_var_; \ | | | | 113| 4.07k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 368, False: 1.11k] | | | | | Branch (113:8): [True: 674, False: 439] | | | | ------------------ | | | | 114| 1.48k| _csi_boolean_var_ = 1; \ | | | | 115| 1.48k| else \ | | | | 116| 1.48k| _csi_boolean_var_ = 0; \ | | | | 117| 1.48k| _csi_boolean_var_; \ | | | | 118| 1.48k|}) | | ------------------ | | | Branch (120:29): [True: 1.04k, False: 439] | | ------------------ ------------------ 312| 1.04k| return FALSE; ------------------ | | 51| 1.04k|#define FALSE 0 ------------------ 313| 1.48k| } else 314| 2.83k| return FALSE; ------------------ | | 51| 2.83k|#define FALSE 0 ------------------ 315| 8.00M| } else if (*s <= '9') { ------------------ | Branch (315:13): [True: 7.98M, False: 21.0k] ------------------ 316| 7.98M| int v = *s - '0'; 317| 7.98M| if (_csi_unlikely (radix && v >= radix)) ------------------ | | 120| 7.98M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 7.98M| __extension__ ({ \ | | | | 112| 7.98M| int _csi_boolean_var_; \ | | | | 113| 15.9M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3.73k, False: 7.97M] | | | | | Branch (113:8): [True: 22, False: 3.71k] | | | | ------------------ | | | | 114| 7.98M| _csi_boolean_var_ = 1; \ | | | | 115| 7.98M| else \ | | | | 116| 7.98M| _csi_boolean_var_ = 0; \ | | | | 117| 7.98M| _csi_boolean_var_; \ | | | | 118| 7.98M|}) | | ------------------ | | | Branch (120:29): [True: 22, False: 7.98M] | | ------------------ ------------------ 318| 22| return FALSE; ------------------ | | 51| 22|#define FALSE 0 ------------------ 319| | 320| 7.98M| if (exponent_sign) { ------------------ | Branch (320:10): [True: 15.7k, False: 7.96M] ------------------ 321| 15.7k| exponent = 10 * exponent + v; 322| 7.96M| } else { 323| 7.96M| if (radix) ------------------ | Branch (323:7): [True: 3.71k, False: 7.96M] ------------------ 324| 3.71k| mantissa = radix * mantissa + v; 325| 7.96M| else 326| 7.96M| mantissa = 10 * mantissa + v; 327| 7.96M| if (decimal != -1) ------------------ | Branch (327:7): [True: 6.67M, False: 1.29M] ------------------ 328| 6.67M| decimal++; 329| 7.96M| } 330| 7.98M| } else if (*s == 'E' || * s== 'e') { ------------------ | Branch (330:13): [True: 14.1k, False: 6.94k] | Branch (330:26): [True: 3.54k, False: 3.40k] ------------------ 331| 17.6k| if (radix == 0) { ------------------ | Branch (331:10): [True: 15.3k, False: 2.34k] ------------------ 332| 15.3k| if (_csi_unlikely (s + 1 == end)) ------------------ | | 120| 15.3k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 15.3k| __extension__ ({ \ | | | | 112| 15.3k| int _csi_boolean_var_; \ | | | | 113| 15.3k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 99, False: 15.2k] | | | | ------------------ | | | | 114| 15.3k| _csi_boolean_var_ = 1; \ | | | | 115| 15.3k| else \ | | | | 116| 15.3k| _csi_boolean_var_ = 0; \ | | | | 117| 15.3k| _csi_boolean_var_; \ | | | | 118| 15.3k|}) | | ------------------ | | | Branch (120:29): [True: 99, False: 15.2k] | | ------------------ ------------------ 333| 99| return FALSE; ------------------ | | 51| 99|#define FALSE 0 ------------------ 334| | 335| 15.2k| exponent_sign = 1; 336| 15.2k| if (s[1] == '-') { ------------------ | Branch (336:7): [True: 6.27k, False: 8.94k] ------------------ 337| 6.27k| exponent_sign = -1; 338| 6.27k| s++; 339| 8.94k| } else if (s[1] == '+') ------------------ | Branch (339:14): [True: 229, False: 8.71k] ------------------ 340| 229| s++; 341| 15.2k| } else { 342| 2.34k| int v = 0xe; 343| | 344| 2.34k| if (_csi_unlikely (v >= radix)) ------------------ | | 120| 2.34k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.34k| __extension__ ({ \ | | | | 112| 2.34k| int _csi_boolean_var_; \ | | | | 113| 2.34k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 2.34k] | | | | ------------------ | | | | 114| 2.34k| _csi_boolean_var_ = 1; \ | | | | 115| 2.34k| else \ | | | | 116| 2.34k| _csi_boolean_var_ = 0; \ | | | | 117| 2.34k| _csi_boolean_var_; \ | | | | 118| 2.34k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 2.34k] | | ------------------ ------------------ 345| 2| return FALSE; ------------------ | | 51| 2|#define FALSE 0 ------------------ 346| | 347| 2.34k| mantissa = radix * mantissa + v; 348| 2.34k| } 349| 17.6k| } else if (*s < 'A') { ------------------ | Branch (349:13): [True: 106, False: 3.29k] ------------------ 350| 106| return FALSE; ------------------ | | 51| 106|#define FALSE 0 ------------------ 351| 3.29k| } else if (*s <= 'Z') { ------------------ | Branch (351:13): [True: 2.37k, False: 924] ------------------ 352| 2.37k| int v = *s - 'A' + 0xA; 353| | 354| 2.37k| if (_csi_unlikely (v >= radix)) ------------------ | | 120| 2.37k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 2.37k| __extension__ ({ \ | | | | 112| 2.37k| int _csi_boolean_var_; \ | | | | 113| 2.37k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1.87k, False: 501] | | | | ------------------ | | | | 114| 2.37k| _csi_boolean_var_ = 1; \ | | | | 115| 2.37k| else \ | | | | 116| 2.37k| _csi_boolean_var_ = 0; \ | | | | 117| 2.37k| _csi_boolean_var_; \ | | | | 118| 2.37k|}) | | ------------------ | | | Branch (120:29): [True: 1.87k, False: 501] | | ------------------ ------------------ 355| 1.87k| return FALSE; ------------------ | | 51| 1.87k|#define FALSE 0 ------------------ 356| | 357| 501| mantissa = radix * mantissa + v; 358| 924| } else if (*s < 'a') { ------------------ | Branch (358:13): [True: 71, False: 853] ------------------ 359| 71| return FALSE; ------------------ | | 51| 71|#define FALSE 0 ------------------ 360| 853| } else if (*s <= 'z') { ------------------ | Branch (360:13): [True: 585, False: 268] ------------------ 361| 585| int v = *s - 'a' + 0xa; 362| | 363| 585| if (_csi_unlikely (v >= radix)) ------------------ | | 120| 585|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 585| __extension__ ({ \ | | | | 112| 585| int _csi_boolean_var_; \ | | | | 113| 585| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 326, False: 259] | | | | ------------------ | | | | 114| 585| _csi_boolean_var_ = 1; \ | | | | 115| 585| else \ | | | | 116| 585| _csi_boolean_var_ = 0; \ | | | | 117| 585| _csi_boolean_var_; \ | | | | 118| 585|}) | | ------------------ | | | Branch (120:29): [True: 326, False: 259] | | ------------------ ------------------ 364| 326| return FALSE; ------------------ | | 51| 326|#define FALSE 0 ------------------ 365| | 366| 259| mantissa = radix * mantissa + v; 367| 259| } else 368| 268| return FALSE; ------------------ | | 51| 268|#define FALSE 0 ------------------ 369| 8.00M| } 370| | 371| 218k| if (exponent_sign || decimal != -1) { ------------------ | Branch (371:9): [True: 12.1k, False: 206k] | Branch (371:26): [True: 98.9k, False: 107k] ------------------ 372| 111k| if (mantissa == 0) { ------------------ | Branch (372:6): [True: 13.8k, False: 97.2k] ------------------ 373| 13.8k| obj->type = CSI_OBJECT_TYPE_REAL; 374| 13.8k| obj->datum.real = 0.; 375| 13.8k| return TRUE; ------------------ | | 55| 13.8k|#define TRUE (!FALSE) | | ------------------ | | | | 51| 13.8k|#define FALSE 0 | | ------------------ ------------------ 376| 97.2k| } else { 377| 97.2k| int e; 378| 97.2k| double v; 379| | 380| 97.2k| v = mantissa; 381| 97.2k| e = exponent * exponent_sign; 382| 97.2k| if (decimal != -1) ------------------ | Branch (382:10): [True: 85.1k, False: 12.0k] ------------------ 383| 85.1k| e -= decimal; 384| 97.2k| switch (e) { 385| 386| case -7: v *= 0.0000001; break; ------------------ | Branch (385:6): [True: 386, False: 96.8k] ------------------ 386| 256| case -6: v *= 0.000001; break; ------------------ | Branch (386:6): [True: 256, False: 96.9k] ------------------ 387| 298| case -5: v *= 0.00001; break; ------------------ | Branch (387:6): [True: 298, False: 96.9k] ------------------ 388| 113| case -4: v *= 0.0001; break; ------------------ | Branch (388:6): [True: 113, False: 97.1k] ------------------ 389| 8.02k| case -3: v *= 0.001; break; ------------------ | Branch (389:6): [True: 8.02k, False: 89.1k] ------------------ 390| 32.0k| case -2: v *= 0.01; break; ------------------ | Branch (390:6): [True: 32.0k, False: 65.2k] ------------------ 391| 43.5k| case -1: v *= 0.1; break; ------------------ | Branch (391:6): [True: 43.5k, False: 53.6k] ------------------ 392| 6.29k| case 0: break; ------------------ | Branch (392:6): [True: 6.29k, False: 90.9k] ------------------ 393| 565| case 1: v *= 10; break; ------------------ | Branch (393:6): [True: 565, False: 96.6k] ------------------ 394| 231| case 2: v *= 100; break; ------------------ | Branch (394:6): [True: 231, False: 96.9k] ------------------ 395| 3.37k| case 3: v *= 1000; break; ------------------ | Branch (395:6): [True: 3.37k, False: 93.8k] ------------------ 396| 321| case 4: v *= 10000; break; ------------------ | Branch (396:6): [True: 321, False: 96.8k] ------------------ 397| 8| case 5: v *= 100000; break; ------------------ | Branch (397:6): [True: 8, False: 97.2k] ------------------ 398| 383| case 6: v *= 1000000; break; ------------------ | Branch (398:6): [True: 383, False: 96.8k] ------------------ 399| 1.38k| default: ------------------ | Branch (399:6): [True: 1.38k, False: 95.8k] ------------------ 400| 1.38k| v *= pow (10, e); /* XXX */ 401| 1.38k| break; 402| 97.2k| } 403| | 404| 97.2k| obj->type = CSI_OBJECT_TYPE_REAL; 405| 97.2k| obj->datum.real = sign * v; 406| 97.2k| return TRUE; ------------------ | | 55| 97.2k|#define TRUE (!FALSE) | | ------------------ | | | | 51| 97.2k|#define FALSE 0 | | ------------------ ------------------ 407| 97.2k| } 408| 111k| } else { 409| 107k| obj->type = CSI_OBJECT_TYPE_INTEGER; 410| 107k| obj->datum.integer = sign * mantissa; 411| 107k| return TRUE; ------------------ | | 55| 107k|#define TRUE (!FALSE) | | ------------------ | | | | 51| 107k|#define FALSE 0 | | ------------------ ------------------ 412| 107k| } 413| 218k|} _csi_scanner_init: 1360| 5.14k|{ 1361| 5.14k| csi_status_t status; 1362| | 1363| 5.14k| memset (scanner, 0, sizeof (csi_scanner_t)); 1364| | 1365| 5.14k| status = buffer_init (ctx, &scanner->buffer); 1366| 5.14k| if (status) ------------------ | Branch (1366:9): [True: 0, False: 5.14k] ------------------ 1367| 0| return status; 1368| | 1369| 5.14k| status = _csi_stack_init (ctx, &scanner->procedure_stack, 4); 1370| 5.14k| if (status) ------------------ | Branch (1370:9): [True: 0, False: 5.14k] ------------------ 1371| 0| return status; 1372| | 1373| 5.14k| scanner->bind = 0; 1374| 5.14k| scanner->push = _scan_push; 1375| 5.14k| scanner->execute = _scan_execute; 1376| | 1377| 5.14k| return CSI_STATUS_SUCCESS; 1378| 5.14k|} _csi_scanner_fini: 1382| 5.14k|{ 1383| 5.14k| buffer_fini (ctx, &scanner->buffer); 1384| 5.14k| _csi_stack_fini (ctx, &scanner->procedure_stack); 1385| 5.14k| if (scanner->build_procedure.type != CSI_OBJECT_TYPE_NULL) ------------------ | Branch (1385:9): [True: 517, False: 4.63k] ------------------ 1386| 517| csi_object_free (ctx, &scanner->build_procedure); 1387| 5.14k|} _csi_scan_file: 1391| 5.14k|{ 1392| 5.14k| csi_status_t status; 1393| 5.14k| int old_line_number; 1394| | 1395| | /* This function needs to be reentrant to handle recursive scanners. 1396| | * i.e. one script executes a second. 1397| | */ 1398| | 1399| 5.14k| if (ctx->scanner.depth++ == 0) { ------------------ | Branch (1399:9): [True: 5.14k, False: 0] ------------------ 1400| 5.14k| if ((status = setjmp (ctx->scanner.jump_buffer))) { ------------------ | Branch (1400:6): [True: 3.15k, False: 1.99k] ------------------ 1401| 3.15k| ctx->scanner.depth = 0; 1402| 3.15k| return status; 1403| 3.15k| } 1404| 5.14k| } 1405| | 1406| 1.99k| old_line_number = ctx->scanner.line_number; 1407| 1.99k| ctx->scanner.line_number = 0; 1408| | 1409| 1.99k| _scan_file (ctx, src); 1410| | 1411| 1.99k| ctx->scanner.line_number = old_line_number; 1412| | 1413| 1.99k| --ctx->scanner.depth; 1414| 1.99k| return CSI_STATUS_SUCCESS; 1415| 5.14k|} cairo-script-scanner.c:buffer_init: 172| 5.14k|{ 173| 5.14k| cairo_status_t status = CSI_STATUS_SUCCESS; 174| | 175| 5.14k| buffer->size = 16384; 176| 5.14k| buffer->base = _csi_alloc (ctx, buffer->size); 177| 5.14k| if (_csi_unlikely (buffer->base == NULL)) { ------------------ | | 120| 5.14k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.14k| __extension__ ({ \ | | | | 112| 5.14k| int _csi_boolean_var_; \ | | | | 113| 5.14k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.14k] | | | | ------------------ | | | | 114| 5.14k| _csi_boolean_var_ = 1; \ | | | | 115| 5.14k| else \ | | | | 116| 5.14k| _csi_boolean_var_ = 0; \ | | | | 117| 5.14k| _csi_boolean_var_; \ | | | | 118| 5.14k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.14k] | | ------------------ ------------------ 178| 0| status = _csi_error (CSI_STATUS_NO_MEMORY); 179| 0| buffer->size = 0; 180| 0| } 181| | 182| 5.14k| buffer->ptr = buffer->base; 183| 5.14k| buffer->end = buffer->base + buffer->size; 184| | 185| 5.14k| return status; 186| 5.14k|} cairo-script-scanner.c:_scan_push: 1340| 1.19M|{ 1341| 1.19M| if (DEBUG_SCAN) { ------------------ | | 52| 1.19M|#define DEBUG_SCAN 0 | | ------------------ | | | Branch (52:20): [Folded, False: 1.19M] | | ------------------ ------------------ 1342| 0| fprintf (stderr, "push "); 1343| | fprintf_obj (stderr, ctx, obj); 1344| 0| } 1345| 1.19M| return _csi_push_ostack (ctx, obj); 1346| 1.19M|} cairo-script-scanner.c:_scan_execute: 1350| 4.02M|{ 1351| 4.02M| if (DEBUG_SCAN) { ------------------ | | 52| 4.02M|#define DEBUG_SCAN 0 | | ------------------ | | | Branch (52:20): [Folded, False: 4.02M] | | ------------------ ------------------ 1352| 0| fprintf (stderr, "exec "); 1353| | fprintf_obj (stderr, ctx, obj); 1354| 0| } 1355| 4.02M| return csi_object_execute (ctx, obj); 1356| 4.02M|} cairo-script-scanner.c:buffer_fini: 190| 5.14k|{ 191| 5.14k| _csi_free (ctx, buffer->base); 192| 5.14k|} cairo-script-scanner.c:_scan_file: 820| 5.14k|{ 821| 5.14k| csi_scanner_t *scan = &ctx->scanner; 822| 5.14k| int c, next; 823| 5.14k| union { 824| 5.14k| int8_t i8; 825| 5.14k| uint8_t u8; 826| 5.14k| int16_t i16; 827| 5.14k| uint16_t u16; 828| 5.14k| int32_t i32; 829| 5.14k| uint32_t u32; 830| 5.14k| float f; 831| 5.14k| } u; 832| 5.14k| int deflate = 0; 833| 5.14k| int string_p; 834| | 835| 5.50M|scan_none: 836| 8.02M| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (836:12): [True: 8.02M, False: 1.19k] ------------------ 837| 8.02M| csi_object_t obj = { CSI_OBJECT_TYPE_NULL }; 838| | 839| 8.02M| switch (c) { 840| 37.8k| case 0xa: ------------------ | Branch (840:2): [True: 37.8k, False: 7.98M] ------------------ 841| 37.8k| scan->line_number++; 842| 140k| case 0x0: ------------------ | Branch (842:2): [True: 102k, False: 7.92M] ------------------ 843| 140k| case 0x9: ------------------ | Branch (843:2): [True: 303, False: 8.02M] ------------------ 844| 145k| case 0xc: ------------------ | Branch (844:2): [True: 4.68k, False: 8.01M] ------------------ 845| 147k| case 0xd: ------------------ | Branch (845:2): [True: 2.60k, False: 8.02M] ------------------ 846| 1.19M| case 0x20: /* ignore whitespace */ ------------------ | Branch (846:2): [True: 1.04M, False: 6.97M] ------------------ 847| 1.19M| break; 848| | 849| 725| case '%': ------------------ | Branch (849:2): [True: 725, False: 8.02M] ------------------ 850| 725| goto scan_comment; 851| | 852| 1.15k| case '(': ------------------ | Branch (852:2): [True: 1.15k, False: 8.02M] ------------------ 853| 1.15k| goto scan_string; 854| | 855| 3.05M| case '[': /* needs special case */ ------------------ | Branch (855:2): [True: 3.05M, False: 4.96M] ------------------ 856| 4.15M| case ']': ------------------ | Branch (856:2): [True: 1.09M, False: 6.92M] ------------------ 857| 4.94M| case '{': ------------------ | Branch (857:2): [True: 790k, False: 7.23M] ------------------ 858| 4.94M| case '}': ------------------ | Branch (858:2): [True: 381, False: 8.02M] ------------------ 859| 4.94M| token_start (scan); 860| 4.94M| token_add_unchecked (scan, c); 861| 4.94M| token_end (ctx, scan, src); 862| 4.94M| goto scan_none; 863| | 864| 199k| case '<': ------------------ | Branch (864:2): [True: 199k, False: 7.82M] ------------------ 865| 199k| next = csi_file_getc (src); 866| 199k| switch (next) { 867| 40| case EOF: ------------------ | Branch (867:6): [True: 40, False: 199k] ------------------ 868| 40| csi_file_putc (src, '<'); 869| 40| return; 870| 1.05k| case '<': ------------------ | Branch (870:6): [True: 1.05k, False: 198k] ------------------ 871| | /* dictionary name */ 872| 1.05k| token_start (scan); 873| 1.05k| token_add_unchecked (scan, '<'); 874| 1.05k| token_add_unchecked (scan, '<'); 875| 1.05k| token_end (ctx, scan, src); 876| 1.05k| goto scan_none; 877| 361| case '|': ------------------ | Branch (877:6): [True: 361, False: 199k] ------------------ 878| 361| deflate = 1; 879| 1.08k| case '~': ------------------ | Branch (879:6): [True: 726, False: 198k] ------------------ 880| 1.08k| goto scan_base85; 881| 1.64k| case '{': ------------------ | Branch (881:6): [True: 1.64k, False: 198k] ------------------ 882| 1.64k| goto scan_base64; 883| 195k| default: ------------------ | Branch (883:6): [True: 195k, False: 3.82k] ------------------ 884| 195k| csi_file_putc (src, next); 885| 195k| goto scan_hex; 886| 199k| } 887| 0| break; 888| | 889| | /* binary token */ 890| 0|#define MSB_INT8 128 891| 0|#define MSB_UINT8 129 892| 0|#define MSB_INT16 130 893| 0|#define MSB_UINT16 131 894| 0|#define MSB_INT32 132 895| 0|#define LSB_INT8 MSB_INT8 896| 0|#define LSB_UINT8 MSB_UINT8 897| 0|#define LSB_INT16 133 898| 0|#define LSB_UINT16 134 899| 0|#define LSB_INT32 135 900| 0|#define MSB_FLOAT32 140 901| 0|#define LSB_FLOAT32 141 902| 23.7k| case MSB_INT8: ------------------ | | 890| 23.7k|#define MSB_INT8 128 ------------------ | Branch (902:2): [True: 23.7k, False: 7.99M] ------------------ 903| 23.7k| scan_read (scan, src, &u.i8, 1); 904| 23.7k| csi_integer_new (&obj, u.i8); 905| 23.7k| break; 906| 17.6k| case MSB_UINT8: ------------------ | | 891| 17.6k|#define MSB_UINT8 129 ------------------ | Branch (906:2): [True: 17.6k, False: 8.00M] ------------------ 907| 17.6k| scan_read (scan, src, &u.u8, 1); 908| 17.6k| csi_integer_new (&obj, u.u8); 909| 17.6k| break; 910| 5.57k| case MSB_INT16: ------------------ | | 892| 5.57k|#define MSB_INT16 130 ------------------ | Branch (910:2): [True: 5.57k, False: 8.01M] ------------------ 911| 5.57k| scan_read (scan, src, &u.i16, 2); 912| 5.57k| csi_integer_new (&obj, be16 (u.i16)); ------------------ | | 63| 5.57k|#define be16(x) bswap_16 (x) ------------------ 913| 5.57k| break; 914| 22.0k| case LSB_INT16: ------------------ | | 897| 22.0k|#define LSB_INT16 133 ------------------ | Branch (914:2): [True: 22.0k, False: 8.00M] ------------------ 915| 22.0k| scan_read (scan, src, &u.i16, 2); 916| 22.0k| csi_integer_new (&obj, le16 (u.i16)); ------------------ | | 61| 22.0k|#define le16(x) x ------------------ 917| 22.0k| break; 918| 1.68k| case MSB_UINT16: ------------------ | | 893| 1.68k|#define MSB_UINT16 131 ------------------ | Branch (918:2): [True: 1.68k, False: 8.02M] ------------------ 919| 1.68k| scan_read (scan, src, &u.u16, 2); 920| 1.68k| csi_integer_new (&obj, be16 (u.u16)); ------------------ | | 63| 1.68k|#define be16(x) bswap_16 (x) ------------------ 921| 1.68k| break; 922| 70.2k| case LSB_UINT16: ------------------ | | 898| 70.2k|#define LSB_UINT16 134 ------------------ | Branch (922:2): [True: 70.2k, False: 7.95M] ------------------ 923| 70.2k| scan_read (scan, src, &u.u16, 2); 924| 70.2k| csi_integer_new (&obj, le16 (u.u16)); ------------------ | | 61| 70.2k|#define le16(x) x ------------------ 925| 70.2k| break; 926| 880| case MSB_INT32: ------------------ | | 894| 880|#define MSB_INT32 132 ------------------ | Branch (926:2): [True: 880, False: 8.02M] ------------------ 927| 880| scan_read (scan, src, &u.i32, 4); 928| 880| csi_integer_new (&obj, be32 (u.i32)); ------------------ | | 64| 880|#define be32(x) bswap_32 (x) ------------------ 929| 880| break; 930| 256k| case LSB_INT32: ------------------ | | 899| 256k|#define LSB_INT32 135 ------------------ | Branch (930:2): [True: 256k, False: 7.76M] ------------------ 931| 256k| scan_read (scan, src, &u.i32, 4); 932| 256k| csi_integer_new (&obj, le32 (u.i32)); ------------------ | | 62| 256k|#define le32(x) x ------------------ 933| 256k| break; 934| | 935| 392| case 136: /* 16.16 msb */ ------------------ | Branch (935:2): [True: 392, False: 8.02M] ------------------ 936| 392| scan_read (scan, src, &u.i32, 4); 937| 392| csi_real_new (&obj, be32 (u.i32) / 65536.); ------------------ | | 64| 392|#define be32(x) bswap_32 (x) ------------------ 938| 392| break; 939| 10.6k| case 137: /* 16.16 lsb */ ------------------ | Branch (939:2): [True: 10.6k, False: 8.01M] ------------------ 940| 10.6k| scan_read (scan, src, &u.i32, 4); 941| 10.6k| csi_real_new (&obj, le32 (u.i32) / 65536.); ------------------ | | 62| 10.6k|#define le32(x) x ------------------ 942| 10.6k| break; 943| 382k| case 138: /* 24.8 msb */ ------------------ | Branch (943:2): [True: 382k, False: 7.64M] ------------------ 944| 382k| scan_read (scan, src, &u.i32, 4); 945| 382k| csi_real_new (&obj, be32 (u.i32) / 256.); ------------------ | | 64| 382k|#define be32(x) bswap_32 (x) ------------------ 946| 382k| break; 947| 433| case 139: /* 24.8 lsb */ ------------------ | Branch (947:2): [True: 433, False: 8.02M] ------------------ 948| 433| scan_read (scan, src, &u.i32, 4); 949| 433| csi_real_new (&obj, le32 (u.i32) / 256.); ------------------ | | 62| 433|#define le32(x) x ------------------ 950| 433| break; 951| 228| case MSB_FLOAT32: ------------------ | | 900| 228|#define MSB_FLOAT32 140 ------------------ | Branch (951:2): [True: 228, False: 8.02M] ------------------ 952| 228| scan_read (scan, src, &u.i32, 4); 953| 228| u.i32 = be32 (u.i32); ------------------ | | 64| 228|#define be32(x) bswap_32 (x) ------------------ 954| 228| csi_real_new (&obj, u.f); 955| 228| break; 956| 5.90k| case LSB_FLOAT32: ------------------ | | 901| 5.90k|#define LSB_FLOAT32 141 ------------------ | Branch (956:2): [True: 5.90k, False: 8.01M] ------------------ 957| 5.90k| scan_read (scan, src, &u.i32, 4); 958| 5.90k| u.i32 = le32 (u.i32); ------------------ | | 62| 5.90k|#define le32(x) x ------------------ 959| 5.90k| csi_real_new (&obj, u.f); 960| 5.90k| break; 961| | 962| 0|#define STRING_1 142 963| 0|#define STRING_2_MSB 144 964| 0|#define STRING_2_LSB 146 965| 0|#define STRING_4_MSB 148 966| 0|#define STRING_4_LSB 150 967| 0|#define STRING_DEFLATE 1 968| 399| case STRING_1: ------------------ | | 962| 399|#define STRING_1 142 ------------------ | Branch (968:2): [True: 399, False: 8.02M] ------------------ 969| 1.91k| case STRING_1 | STRING_DEFLATE: ------------------ | | 962| 1.91k|#define STRING_1 142 ------------------ case STRING_1 | STRING_DEFLATE: ------------------ | | 967| 1.91k|#define STRING_DEFLATE 1 ------------------ | Branch (969:2): [True: 1.51k, False: 8.02M] ------------------ 970| 1.91k| scan_read (scan, src, &u.u8, 1); 971| 1.91k| string_read (ctx, scan, src, u.u8, c & STRING_DEFLATE, &obj); ------------------ | | 967| 1.91k|#define STRING_DEFLATE 1 ------------------ 972| 1.91k| break; 973| 262| case STRING_2_MSB: ------------------ | | 963| 262|#define STRING_2_MSB 144 ------------------ | Branch (973:2): [True: 262, False: 8.02M] ------------------ 974| 378| case STRING_2_MSB | STRING_DEFLATE: ------------------ | | 963| 378|#define STRING_2_MSB 144 ------------------ case STRING_2_MSB | STRING_DEFLATE: ------------------ | | 967| 378|#define STRING_DEFLATE 1 ------------------ | Branch (974:2): [True: 116, False: 8.02M] ------------------ 975| 378| scan_read (scan, src, &u.u16, 2); 976| 378| string_read (ctx, scan, src, be16 (u.u16), c & STRING_DEFLATE, &obj); ------------------ | | 63| 378|#define be16(x) bswap_16 (x) ------------------ string_read (ctx, scan, src, be16 (u.u16), c & STRING_DEFLATE, &obj); ------------------ | | 967| 378|#define STRING_DEFLATE 1 ------------------ 977| 378| break; 978| 274| case STRING_2_LSB: ------------------ | | 964| 274|#define STRING_2_LSB 146 ------------------ | Branch (978:2): [True: 274, False: 8.02M] ------------------ 979| 357| case STRING_2_LSB | STRING_DEFLATE: ------------------ | | 964| 357|#define STRING_2_LSB 146 ------------------ case STRING_2_LSB | STRING_DEFLATE: ------------------ | | 967| 357|#define STRING_DEFLATE 1 ------------------ | Branch (979:2): [True: 83, False: 8.02M] ------------------ 980| 357| scan_read (scan, src, &u.u16, 2); 981| 357| string_read (ctx, scan, src, le16 (u.u16), c & STRING_DEFLATE, &obj); ------------------ | | 61| 357|#define le16(x) x ------------------ string_read (ctx, scan, src, le16 (u.u16), c & STRING_DEFLATE, &obj); ------------------ | | 967| 357|#define STRING_DEFLATE 1 ------------------ 982| 357| break; 983| 313| case STRING_4_MSB: ------------------ | | 965| 313|#define STRING_4_MSB 148 ------------------ | Branch (983:2): [True: 313, False: 8.02M] ------------------ 984| 627| case STRING_4_MSB | STRING_DEFLATE: ------------------ | | 965| 627|#define STRING_4_MSB 148 ------------------ case STRING_4_MSB | STRING_DEFLATE: ------------------ | | 967| 627|#define STRING_DEFLATE 1 ------------------ | Branch (984:2): [True: 314, False: 8.02M] ------------------ 985| 627| scan_read (scan, src, &u.u32, 4); 986| 627| string_read (ctx, scan, src, be32 (u.u32), c & STRING_DEFLATE, &obj); ------------------ | | 64| 627|#define be32(x) bswap_32 (x) ------------------ string_read (ctx, scan, src, be32 (u.u32), c & STRING_DEFLATE, &obj); ------------------ | | 967| 627|#define STRING_DEFLATE 1 ------------------ 987| 627| break; 988| 98| case STRING_4_LSB: ------------------ | | 966| 98|#define STRING_4_LSB 150 ------------------ | Branch (988:2): [True: 98, False: 8.02M] ------------------ 989| 152| case STRING_4_LSB | STRING_DEFLATE: ------------------ | | 966| 152|#define STRING_4_LSB 150 ------------------ case STRING_4_LSB | STRING_DEFLATE: ------------------ | | 967| 152|#define STRING_DEFLATE 1 ------------------ | Branch (989:2): [True: 54, False: 8.02M] ------------------ 990| 152| scan_read (scan, src, &u.u32, 4); 991| 152| string_read (ctx, scan, src, le32 (u.u32), c & STRING_DEFLATE, &obj); ------------------ | | 62| 152|#define le32(x) x ------------------ string_read (ctx, scan, src, le32 (u.u32), c & STRING_DEFLATE, &obj); ------------------ | | 967| 152|#define STRING_DEFLATE 1 ------------------ 992| 152| break; 993| | 994| 0|#define OPCODE 152 995| 525k| case OPCODE: ------------------ | | 994| 525k|#define OPCODE 152 ------------------ | Branch (995:2): [True: 525k, False: 7.49M] ------------------ 996| 525k| scan_read (scan, src, &u.u8, 1); 997| 525k| csi_operator_new (&obj, ctx->opcode[u.u8]); 998| 525k| break; 999| | 1000| 900| case OPCODE | 1: ------------------ | | 994| 900|#define OPCODE 152 ------------------ | Branch (1000:2): [True: 900, False: 8.02M] ------------------ 1001| 900| scan_read (scan, src, &u.u8, 1); 1002| 900| csi_operator_new (&obj, ctx->opcode[u.u8]); 1003| 900| obj.type &= ~CSI_OBJECT_ATTR_EXECUTABLE; 1004| 900| break; 1005| | 1006| 0|#define STRING_LZO 154 1007| 363| case STRING_LZO: ------------------ | | 1006| 363|#define STRING_LZO 154 ------------------ | Branch (1007:2): [True: 363, False: 8.02M] ------------------ 1008| 363| scan_read (scan, src, &u.u32, 4); 1009| 363| string_read (ctx, scan, src, be32 (u.u32), LZO, &obj); ------------------ | | 64| 363|#define be32(x) bswap_32 (x) ------------------ 1010| 363| break; 1011| | 1012| | /* unassigned */ 1013| 1| case 155: ------------------ | Branch (1013:2): [True: 1, False: 8.02M] ------------------ 1014| 2| case 156: ------------------ | Branch (1014:2): [True: 1, False: 8.02M] ------------------ 1015| 7| case 157: ------------------ | Branch (1015:2): [True: 5, False: 8.02M] ------------------ 1016| 9| case 158: ------------------ | Branch (1016:2): [True: 2, False: 8.02M] ------------------ 1017| 10| case 159: ------------------ | Branch (1017:2): [True: 1, False: 8.02M] ------------------ 1018| 10| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1019| | 1020| 10.9k| case '#': /* PDF 1.2 escape code */ ------------------ | Branch (1020:2): [True: 10.9k, False: 8.01M] ------------------ 1021| 10.9k| { 1022| 10.9k| int c_hi = csi_file_getc (src); 1023| 10.9k| int c_lo = csi_file_getc (src); 1024| 10.9k| c = (hex_value (c_hi) << 4) | hex_value (c_lo); 1025| 10.9k| } 1026| | /* fall-through */ 1027| 358k| default: ------------------ | Branch (1027:2): [True: 347k, False: 7.67M] ------------------ 1028| 358k| token_start (scan); 1029| 358k| token_add_unchecked (scan, c); 1030| 358k| goto scan_token; 1031| 8.02M| } 1032| | 1033| 2.51M| if (obj.type != CSI_OBJECT_TYPE_NULL) { ------------------ | Branch (1033:6): [True: 1.32M, False: 1.19M] ------------------ 1034| 1.32M| cairo_status_t status; 1035| | 1036| 1.32M| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) { ------------------ | Branch (1036:10): [True: 10.4k, False: 1.31M] ------------------ 1037| 10.4k| status = csi_array_append (ctx, 1038| 10.4k| scan->build_procedure.datum.array, 1039| 10.4k| &obj); 1040| 1.31M| } else if (obj.type & CSI_OBJECT_ATTR_EXECUTABLE) { ------------------ | Branch (1040:17): [True: 524k, False: 792k] ------------------ 1041| 524k| status = scan_execute (ctx, &obj); 1042| 524k| csi_object_free (ctx, &obj); 1043| 792k| } else { 1044| 792k| status = scan_push (ctx, &obj); 1045| 792k| } 1046| 1.32M| if (_csi_unlikely (status)) ------------------ | | 120| 1.32M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.32M| __extension__ ({ \ | | | | 112| 1.32M| int _csi_boolean_var_; \ | | | | 113| 1.32M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 990, False: 1.32M] | | | | ------------------ | | | | 114| 1.32M| _csi_boolean_var_ = 1; \ | | | | 115| 1.32M| else \ | | | | 116| 1.32M| _csi_boolean_var_ = 0; \ | | | | 117| 1.32M| _csi_boolean_var_; \ | | | | 118| 1.32M|}) | | ------------------ | | | Branch (120:29): [True: 990, False: 1.32M] | | ------------------ ------------------ 1047| 990| longjmp (scan->jump_buffer, status); 1048| 1.32M| } 1049| 2.51M| } 1050| 1.19k| return; 1051| | 1052| 362k|scan_token: 1053| 21.7M| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1053:12): [True: 21.7M, False: 1.28k] ------------------ 1054| 21.7M| switch (c) { 1055| 37.8k| case 0xa: ------------------ | Branch (1055:2): [True: 37.8k, False: 21.7M] ------------------ 1056| 37.8k| scan->line_number++; 1057| | /* fall through */ 1058| 129k| case 0x0: ------------------ | Branch (1058:2): [True: 91.7k, False: 21.6M] ------------------ 1059| 137k| case 0x9: ------------------ | Branch (1059:2): [True: 7.94k, False: 21.7M] ------------------ 1060| 137k| case 0xc: ------------------ | Branch (1060:2): [True: 253, False: 21.7M] ------------------ 1061| 139k| case 0xd: ------------------ | Branch (1061:2): [True: 1.90k, False: 21.7M] ------------------ 1062| 275k| case 0x20: ------------------ | Branch (1062:2): [True: 136k, False: 21.6M] ------------------ 1063| 275k| token_end (ctx, scan, src); 1064| 275k| goto scan_none; 1065| | 1066| | /* syntax delimiters */ 1067| 627| case '%': ------------------ | Branch (1067:2): [True: 627, False: 21.7M] ------------------ 1068| 627| token_end (ctx, scan, src); 1069| 627| goto scan_comment; 1070| | /* syntax error? */ 1071| 3.96k| case '(': ------------------ | Branch (1071:2): [True: 3.96k, False: 21.7M] ------------------ 1072| 3.96k| token_end (ctx, scan, src); 1073| 3.96k| goto scan_string; 1074| | /* XXX syntax error? */ 1075| 1.02k| case ')': ------------------ | Branch (1075:2): [True: 1.02k, False: 21.7M] ------------------ 1076| 1.02k| token_end (ctx, scan, src); 1077| 1.02k| goto scan_none; 1078| 3.87k| case '/': ------------------ | Branch (1078:2): [True: 3.87k, False: 21.7M] ------------------ 1079| | /* need to special case '^//?' */ 1080| 3.87k| if (scan->buffer.ptr > scan->buffer.base+1 || ------------------ | Branch (1080:10): [True: 3.19k, False: 678] ------------------ 1081| 678| scan->buffer.base[0] != '/') ------------------ | Branch (1081:3): [True: 480, False: 198] ------------------ 1082| 3.67k| { 1083| 3.67k| token_end (ctx, scan, src); 1084| 3.67k| token_start (scan); 1085| 3.67k| } 1086| 3.87k| token_add_unchecked (scan, '/'); 1087| 3.87k| goto scan_token; 1088| | 1089| 36.8k| case '{': ------------------ | Branch (1089:2): [True: 36.8k, False: 21.7M] ------------------ 1090| 45.1k| case '}': ------------------ | Branch (1090:2): [True: 8.32k, False: 21.7M] ------------------ 1091| 68.0k| case ']': ------------------ | Branch (1091:2): [True: 22.8k, False: 21.7M] ------------------ 1092| 68.0k| token_end (ctx, scan, src); 1093| 68.0k| token_start (scan); 1094| 68.0k| token_add_unchecked (scan, c); 1095| 68.0k| token_end (ctx, scan, src); 1096| 68.0k| goto scan_none; 1097| | 1098| 7.64k| case '<': ------------------ | Branch (1098:2): [True: 7.64k, False: 21.7M] ------------------ 1099| 7.64k| csi_file_putc (src, '<'); 1100| 7.64k| token_end (ctx, scan, src); 1101| 7.64k| goto scan_none; 1102| | 1103| 3.20k| case '#': /* PDF 1.2 escape code */ ------------------ | Branch (1103:2): [True: 3.20k, False: 21.7M] ------------------ 1104| 3.20k| { 1105| 3.20k| int c_hi = csi_file_getc (src); 1106| 3.20k| int c_lo = csi_file_getc (src); 1107| 3.20k| c = (hex_value (c_hi) << 4) | hex_value (c_lo); 1108| 3.20k| } 1109| | /* fall-through */ 1110| 21.4M| default: ------------------ | Branch (1110:2): [True: 21.4M, False: 364k] ------------------ 1111| 21.4M| token_add (ctx, scan, c); 1112| 21.4M| break; 1113| 21.7M| } 1114| 21.7M| } 1115| 1.28k| token_end (ctx, scan, src); 1116| 1.28k| return; 1117| | 1118| 1.34k|scan_comment: 1119| | /* discard until newline */ 1120| 5.59k| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1120:12): [True: 5.57k, False: 27] ------------------ 1121| 5.57k| switch (c) { ------------------ | Branch (1121:10): [True: 1.31k, False: 4.25k] ------------------ 1122| 783| case 0xa: ------------------ | Branch (1122:2): [True: 783, False: 4.78k] ------------------ 1123| 783| scan->line_number++; 1124| 1.31k| case 0xc: ------------------ | Branch (1124:2): [True: 534, False: 5.03k] ------------------ 1125| 1.31k| goto scan_none; 1126| 5.57k| } 1127| 5.57k| } 1128| 27| return; 1129| | 1130| 5.11k|scan_string: 1131| 5.11k| buffer_reset (&scan->buffer); 1132| 5.11k| string_p = 1; 1133| 5.59M| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1133:12): [True: 5.59M, False: 207] ------------------ 1134| 5.59M| switch (c) { 1135| 1.19M| case '\\': /* escape */ ------------------ | Branch (1135:2): [True: 1.19M, False: 4.40M] ------------------ 1136| 1.19M| next = csi_file_getc (src); 1137| 1.19M| switch (next) { 1138| 39| case EOF: ------------------ | Branch (1138:6): [True: 39, False: 1.19M] ------------------ 1139| 39| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1140| | 1141| 360k| case 'n': ------------------ | Branch (1141:6): [True: 360k, False: 835k] ------------------ 1142| 360k| string_add (ctx, scan, '\n'); 1143| 360k| break; 1144| 248k| case 'r': ------------------ | Branch (1144:6): [True: 248k, False: 947k] ------------------ 1145| 248k| string_add (ctx, scan, '\r'); 1146| 248k| break; 1147| 199| case 't': ------------------ | Branch (1147:6): [True: 199, False: 1.19M] ------------------ 1148| 199| string_add (ctx, scan, '\t'); 1149| 199| break; 1150| 34.4k| case 'b': ------------------ | Branch (1150:6): [True: 34.4k, False: 1.16M] ------------------ 1151| 34.4k| string_add (ctx, scan, '\b'); 1152| 34.4k| break; 1153| 254| case 'f': ------------------ | Branch (1153:6): [True: 254, False: 1.19M] ------------------ 1154| 254| string_add (ctx, scan, '\f'); 1155| 254| break; 1156| 219k| case '\\': ------------------ | Branch (1156:6): [True: 219k, False: 976k] ------------------ 1157| 219k| string_add (ctx, scan, '\\'); 1158| 219k| break; 1159| 203k| case '(': ------------------ | Branch (1159:6): [True: 203k, False: 992k] ------------------ 1160| 203k| string_add (ctx, scan, '('); 1161| 203k| break; 1162| 64.0k| case ')': ------------------ | Branch (1162:6): [True: 64.0k, False: 1.13M] ------------------ 1163| 64.0k| string_add (ctx, scan, ')'); 1164| 64.0k| break; 1165| | 1166| 26.2k| case '0': case '1': case '2': case '3': ------------------ | Branch (1166:6): [True: 12.7k, False: 1.18M] | Branch (1166:16): [True: 4.98k, False: 1.19M] | Branch (1166:26): [True: 7.18k, False: 1.18M] | Branch (1166:36): [True: 1.32k, False: 1.19M] ------------------ 1167| 35.8k| case '4': case '5': case '6': case '7': ------------------ | Branch (1167:6): [True: 299, False: 1.19M] | Branch (1167:16): [True: 244, False: 1.19M] | Branch (1167:26): [True: 8.78k, False: 1.18M] | Branch (1167:36): [True: 237, False: 1.19M] ------------------ 1168| 35.8k| { /* octal code: \d{1,3} */ 1169| 35.8k| int i; 1170| | 1171| 35.8k| c = next - '0'; 1172| | 1173| 68.1k| for (i = 0; i < 2; i++) { ------------------ | Branch (1173:19): [True: 52.7k, False: 15.3k] ------------------ 1174| 52.7k| next = csi_file_getc (src); 1175| 52.7k| switch (next) { 1176| 46| case EOF: ------------------ | Branch (1176:4): [True: 46, False: 52.6k] ------------------ 1177| 46| return; 1178| | 1179| 19.6k| case '0': case '1': case '2': case '3': ------------------ | Branch (1179:4): [True: 17.7k, False: 34.9k] | Branch (1179:14): [True: 590, False: 52.1k] | Branch (1179:24): [True: 869, False: 51.8k] | Branch (1179:34): [True: 401, False: 52.3k] ------------------ 1180| 32.2k| case '4': case '5': case '6': case '7': ------------------ | Branch (1180:4): [True: 339, False: 52.3k] | Branch (1180:14): [True: 6.62k, False: 46.0k] | Branch (1180:24): [True: 383, False: 52.3k] | Branch (1180:34): [True: 5.28k, False: 47.4k] ------------------ 1181| 32.2k| c = 8*c + next-'0'; 1182| 32.2k| break; 1183| | 1184| 20.3k| default: ------------------ | Branch (1184:4): [True: 20.3k, False: 32.3k] ------------------ 1185| 20.3k| csi_file_putc (src, next); 1186| 20.3k| goto octal_code_done; 1187| 52.7k| } 1188| 52.7k| } 1189| 35.7k| octal_code_done: 1190| 35.7k| string_add (ctx, scan, c); 1191| 35.7k| } 1192| 0| break; 1193| | 1194| 228| case 0xa: ------------------ | Branch (1194:6): [True: 228, False: 1.19M] ------------------ 1195| | /* skip the newline */ 1196| 228| next = csi_file_getc (src); /* might be compound LFCR */ 1197| 228| switch (next) { 1198| 5| case EOF: ------------------ | Branch (1198:3): [True: 5, False: 223] ------------------ 1199| 5| return; 1200| 1| case 0xc: ------------------ | Branch (1200:3): [True: 1, False: 227] ------------------ 1201| 1| break; 1202| 222| default: ------------------ | Branch (1202:3): [True: 222, False: 6] ------------------ 1203| 222| csi_file_putc (src, next); 1204| 222| break; 1205| 228| } 1206| 223| scan->line_number++; 1207| 223| break; 1208| 1| case 0xc: ------------------ | Branch (1208:6): [True: 1, False: 1.19M] ------------------ 1209| 1| break; 1210| | 1211| 29.1k| default: ------------------ | Branch (1211:6): [True: 29.1k, False: 1.16M] ------------------ 1212| | /* ignore the '\' */ 1213| 29.1k| break; 1214| 1.19M| } 1215| 1.19M| break; 1216| | 1217| 1.29M| case '(': ------------------ | Branch (1217:2): [True: 1.29M, False: 4.30M] ------------------ 1218| 1.29M| string_p++; 1219| 1.29M| string_add (ctx, scan, c); 1220| 1.29M| break; 1221| | 1222| 189k| case ')': ------------------ | Branch (1222:2): [True: 189k, False: 5.40M] ------------------ 1223| 189k| if (--string_p == 0) { ------------------ | Branch (1223:10): [True: 4.81k, False: 184k] ------------------ 1224| 4.81k| string_end (ctx, scan); 1225| 4.81k| goto scan_none; 1226| 4.81k| } 1227| | /* fall through */ 1228| 3.10M| default: ------------------ | Branch (1228:2): [True: 2.91M, False: 2.67M] ------------------ 1229| 3.10M| string_add (ctx, scan, c); 1230| 3.10M| break; 1231| 5.59M| } 1232| 5.59M| } 1233| 207| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1234| | 1235| 195k|scan_hex: 1236| 195k| buffer_reset (&scan->buffer); 1237| 195k| scan->accumulator_count = 0; 1238| 195k| scan->accumulator = 0; 1239| 2.25M| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1239:12): [True: 2.25M, False: 220] ------------------ 1240| 2.25M| switch (c) { 1241| 290| case 0xa: ------------------ | Branch (1241:2): [True: 290, False: 2.25M] ------------------ 1242| 290| scan->line_number++; 1243| 549| case 0x0: ------------------ | Branch (1243:2): [True: 259, False: 2.25M] ------------------ 1244| 873| case 0x9: ------------------ | Branch (1244:2): [True: 324, False: 2.25M] ------------------ 1245| 9.88k| case 0xc: ------------------ | Branch (1245:2): [True: 9.00k, False: 2.24M] ------------------ 1246| 22.0k| case 0xd: ------------------ | Branch (1246:2): [True: 12.1k, False: 2.24M] ------------------ 1247| 22.1k| case 0x20: /* ignore whitespace */ ------------------ | Branch (1247:2): [True: 69, False: 2.25M] ------------------ 1248| 22.1k| break; 1249| | 1250| 195k| case '>': ------------------ | Branch (1250:2): [True: 195k, False: 2.05M] ------------------ 1251| 195k| hex_end (ctx, scan); /* fixup odd digit with '0' */ 1252| 195k| goto scan_none; 1253| | 1254| 842| case '0': ------------------ | Branch (1254:2): [True: 842, False: 2.25M] ------------------ 1255| 1.62k| case '1': ------------------ | Branch (1255:2): [True: 787, False: 2.25M] ------------------ 1256| 2.03k| case '2': ------------------ | Branch (1256:2): [True: 409, False: 2.25M] ------------------ 1257| 2.56k| case '3': ------------------ | Branch (1257:2): [True: 529, False: 2.25M] ------------------ 1258| 3.50k| case '4': ------------------ | Branch (1258:2): [True: 933, False: 2.25M] ------------------ 1259| 4.19k| case '5': ------------------ | Branch (1259:2): [True: 691, False: 2.25M] ------------------ 1260| 4.62k| case '6': ------------------ | Branch (1260:2): [True: 429, False: 2.25M] ------------------ 1261| 5.33k| case '7': ------------------ | Branch (1261:2): [True: 718, False: 2.25M] ------------------ 1262| 5.77k| case '8': ------------------ | Branch (1262:2): [True: 436, False: 2.25M] ------------------ 1263| 6.55k| case '9': ------------------ | Branch (1263:2): [True: 784, False: 2.25M] ------------------ 1264| 1.85M| case 'a': ------------------ | Branch (1264:2): [True: 1.84M, False: 409k] ------------------ 1265| 1.85M| case 'b': ------------------ | Branch (1265:2): [True: 215, False: 2.25M] ------------------ 1266| 1.85M| case 'c': ------------------ | Branch (1266:2): [True: 229, False: 2.25M] ------------------ 1267| 1.85M| case 'd': ------------------ | Branch (1267:2): [True: 422, False: 2.25M] ------------------ 1268| 1.85M| case 'e': ------------------ | Branch (1268:2): [True: 232, False: 2.25M] ------------------ 1269| 1.85M| case 'f': ------------------ | Branch (1269:2): [True: 489, False: 2.25M] ------------------ 1270| 1.85M| case 'A': ------------------ | Branch (1270:2): [True: 545, False: 2.25M] ------------------ 1271| 1.85M| case 'B': ------------------ | Branch (1271:2): [True: 259, False: 2.25M] ------------------ 1272| 1.85M| case 'C': ------------------ | Branch (1272:2): [True: 1.07k, False: 2.25M] ------------------ 1273| 1.85M| case 'D': ------------------ | Branch (1273:2): [True: 211, False: 2.25M] ------------------ 1274| 1.85M| case 'E': ------------------ | Branch (1274:2): [True: 4.14k, False: 2.25M] ------------------ 1275| 2.03M| case 'F': ------------------ | Branch (1275:2): [True: 177k, False: 2.07M] ------------------ 1276| 2.03M| hex_add (ctx, scan, c); 1277| 2.03M| break; 1278| | 1279| 50| default: ------------------ | Branch (1279:2): [True: 50, False: 2.25M] ------------------ 1280| 50| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1281| 2.25M| } 1282| 2.25M| } 1283| 220| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1284| | 1285| 1.08k|scan_base85: 1286| 1.08k| buffer_reset (&scan->buffer); 1287| 1.08k| scan->accumulator = 0; 1288| 1.08k| scan->accumulator_count = 0; 1289| 722k| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1289:12): [True: 722k, False: 36] ------------------ 1290| 722k| switch (c) { 1291| 1.02k| case '~': ------------------ | Branch (1291:2): [True: 1.02k, False: 721k] ------------------ 1292| 1.02k| next = csi_file_getc (src); 1293| 1.02k| switch (next) { ------------------ | Branch (1293:14): [True: 1.02k, False: 3] ------------------ 1294| 4| case EOF: ------------------ | Branch (1294:6): [True: 4, False: 1.02k] ------------------ 1295| 4| return; 1296| | 1297| 1.01k| case '>': ------------------ | Branch (1297:6): [True: 1.01k, False: 7] ------------------ 1298| 1.01k| base85_end (ctx, scan, deflate); 1299| 1.01k| deflate = 0; 1300| 1.01k| goto scan_none; 1301| 1.02k| } 1302| 3| csi_file_putc (src, next); 1303| | 1304| | /* fall-through */ 1305| 721k| default: ------------------ | Branch (1305:2): [True: 721k, False: 1.02k] ------------------ 1306| 721k| base85_add (ctx, scan, c); 1307| 721k| break; 1308| 722k| } 1309| 722k| } 1310| 36| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1311| | 1312| 1.64k|scan_base64: 1313| 1.64k| buffer_reset (&scan->buffer); 1314| 1.64k| scan->accumulator = 0; 1315| 1.64k| scan->accumulator_count = 0; 1316| 339k| while ((c = csi_file_getc (src)) != EOF) { ------------------ | Branch (1316:12): [True: 339k, False: 143] ------------------ 1317| 339k| switch (c) { 1318| 1.50k| case '}': ------------------ | Branch (1318:2): [True: 1.50k, False: 338k] ------------------ 1319| 1.50k| next = csi_file_getc (src); 1320| 1.50k| switch (next) { ------------------ | Branch (1320:14): [True: 1.50k, False: 2] ------------------ 1321| 2| case EOF: ------------------ | Branch (1321:6): [True: 2, False: 1.50k] ------------------ 1322| 2| return; 1323| | 1324| 1.50k| case '>': ------------------ | Branch (1324:6): [True: 1.50k, False: 4] ------------------ 1325| 1.50k| base64_end (ctx, scan); 1326| 1.50k| goto scan_none; 1327| 1.50k| } 1328| 2| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1329| | 1330| 338k| default: ------------------ | Branch (1330:2): [True: 338k, False: 1.50k] ------------------ 1331| 338k| base64_add (ctx, scan, c); 1332| 338k| break; 1333| 339k| } 1334| 339k| } 1335| 143| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 1336| 1.64k|} cairo-script-scanner.c:token_start: 237| 5.37M|{ 238| 5.37M| buffer_reset (&scan->buffer); 239| 5.37M|} cairo-script-scanner.c:token_add_unchecked: 250| 5.37M|{ 251| 5.37M| buffer_add (&scan->buffer, c); 252| 5.37M|} cairo-script-scanner.c:buffer_add: 225| 34.3M|{ 226| 34.3M| *buffer->ptr++ = c; 227| 34.3M|} cairo-script-scanner.c:token_end: 417| 5.37M|{ 418| 5.37M| cairo_status_t status; 419| 5.37M| char *s; 420| 5.37M| csi_object_t obj; 421| 5.37M| int len; 422| | 423| | /* 424| | * Any token that consists entirely of regular characters and 425| | * cannot be interpreted as a number is treated as a name object 426| | * (more precisely, an executable name). All characters except 427| | * delimiters and white-space characters can appear in names, 428| | * including characters ordinarily considered to be punctuation. 429| | */ 430| | 431| 5.37M| if (_csi_unlikely (scan->buffer.ptr == scan->buffer.base)) ------------------ | | 120| 5.37M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 5.37M| __extension__ ({ \ | | | | 112| 5.37M| int _csi_boolean_var_; \ | | | | 113| 5.37M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 5.37M] | | | | ------------------ | | | | 114| 5.37M| _csi_boolean_var_ = 1; \ | | | | 115| 5.37M| else \ | | | | 116| 5.37M| _csi_boolean_var_ = 0; \ | | | | 117| 5.37M| _csi_boolean_var_; \ | | | | 118| 5.37M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 5.37M] | | ------------------ ------------------ 432| 0| return; 433| | 434| 5.37M| s = scan->buffer.base; 435| 5.37M| len = scan->buffer.ptr - scan->buffer.base; 436| | 437| 5.37M| if (_csi_likely (! scan->bind)) { ------------------ | | 119| 5.37M|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 5.37M| __extension__ ({ \ | | | | 112| 5.37M| int _csi_boolean_var_; \ | | | | 113| 5.37M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5.37M, False: 0] | | | | ------------------ | | | | 114| 5.37M| _csi_boolean_var_ = 1; \ | | | | 115| 5.37M| else \ | | | | 116| 5.37M| _csi_boolean_var_ = 0; \ | | | | 117| 5.37M| _csi_boolean_var_; \ | | | | 118| 5.37M|}) | | ------------------ | | | Branch (119:27): [True: 5.37M, False: 0] | | ------------------ ------------------ 438| 5.37M| if (s[0] == '{') { /* special case procedures */ ------------------ | Branch (438:6): [True: 827k, False: 4.54M] ------------------ 439| 827k| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) { ------------------ | Branch (439:10): [True: 826k, False: 853] ------------------ 440| 826k| status = _csi_stack_push (ctx, 441| 826k| &scan->procedure_stack, 442| 826k| &scan->build_procedure); 443| 826k| if (_csi_unlikely (status)) ------------------ | | 120| 826k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 826k| __extension__ ({ \ | | | | 112| 826k| int _csi_boolean_var_; \ | | | | 113| 826k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 826k] | | | | ------------------ | | | | 114| 826k| _csi_boolean_var_ = 1; \ | | | | 115| 826k| else \ | | | | 116| 826k| _csi_boolean_var_ = 0; \ | | | | 117| 826k| _csi_boolean_var_; \ | | | | 118| 826k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 826k] | | ------------------ ------------------ 444| 0| longjmp (scan->jump_buffer, status); 445| 826k| } 446| | 447| 827k| status = csi_array_new (ctx, 0, &scan->build_procedure); 448| 827k| if (_csi_unlikely (status)) ------------------ | | 120| 827k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 827k| __extension__ ({ \ | | | | 112| 827k| int _csi_boolean_var_; \ | | | | 113| 827k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 827k] | | | | ------------------ | | | | 114| 827k| _csi_boolean_var_ = 1; \ | | | | 115| 827k| else \ | | | | 116| 827k| _csi_boolean_var_ = 0; \ | | | | 117| 827k| _csi_boolean_var_; \ | | | | 118| 827k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 827k] | | ------------------ ------------------ 449| 0| longjmp (scan->jump_buffer, status); 450| | 451| 827k| scan->build_procedure.type |= CSI_OBJECT_ATTR_EXECUTABLE; 452| 827k| return; 453| 4.54M| } else if (s[0] == '}') { ------------------ | Branch (453:13): [True: 8.70k, False: 4.53M] ------------------ 454| 8.70k| if (_csi_unlikely ------------------ | | 120| 8.70k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8.70k| __extension__ ({ \ | | | | 112| 8.70k| int _csi_boolean_var_; \ | | | | 113| 8.70k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2, False: 8.69k] | | | | ------------------ | | | | 114| 8.70k| _csi_boolean_var_ = 1; \ | | | | 115| 8.70k| else \ | | | | 116| 8.70k| _csi_boolean_var_ = 0; \ | | | | 117| 8.70k| _csi_boolean_var_; \ | | | | 118| 8.70k|}) | | ------------------ | | | Branch (120:29): [True: 2, False: 8.69k] | | ------------------ ------------------ 455| 8.70k| (scan->build_procedure.type == CSI_OBJECT_TYPE_NULL)) 456| 2| { 457| 2| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 458| 2| } 459| | 460| 8.69k| if (scan->procedure_stack.len) { ------------------ | Branch (460:10): [True: 8.36k, False: 336] ------------------ 461| 8.36k| csi_object_t *next; 462| | 463| 8.36k| next = _csi_stack_peek (&scan->procedure_stack, 0); 464| 8.36k| status = csi_array_append (ctx, next->datum.array, 465| 8.36k| &scan->build_procedure); 466| 8.36k| scan->build_procedure = *next; 467| 8.36k| scan->procedure_stack.len--; 468| 8.36k| } else { 469| 336| status = scan_push (ctx, &scan->build_procedure); 470| 336| scan->build_procedure.type = CSI_OBJECT_TYPE_NULL; 471| 336| } 472| 8.69k| if (_csi_unlikely (status)) ------------------ | | 120| 8.69k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8.69k| __extension__ ({ \ | | | | 112| 8.69k| int _csi_boolean_var_; \ | | | | 113| 8.69k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 8.69k] | | | | ------------------ | | | | 114| 8.69k| _csi_boolean_var_ = 1; \ | | | | 115| 8.69k| else \ | | | | 116| 8.69k| _csi_boolean_var_ = 0; \ | | | | 117| 8.69k| _csi_boolean_var_; \ | | | | 118| 8.69k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 8.69k] | | ------------------ ------------------ 473| 0| longjmp (scan->jump_buffer, status); 474| | 475| 8.69k| return; 476| 8.69k| } 477| 5.37M| } 478| | 479| 4.53M| if (s[0] == '/') { ------------------ | Branch (479:9): [True: 4.36k, False: 4.53M] ------------------ 480| 4.36k| if (len >= 2 && s[1] == '/') { /* substituted name */ ------------------ | Branch (480:6): [True: 3.34k, False: 1.01k] | Branch (480:18): [True: 198, False: 3.15k] ------------------ 481| 198| status = csi_name_new (ctx, &obj, s + 2, len - 2); 482| 198| if (_csi_unlikely (status)) ------------------ | | 120| 198|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 198| __extension__ ({ \ | | | | 112| 198| int _csi_boolean_var_; \ | | | | 113| 198| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 198] | | | | ------------------ | | | | 114| 198| _csi_boolean_var_ = 1; \ | | | | 115| 198| else \ | | | | 116| 198| _csi_boolean_var_ = 0; \ | | | | 117| 198| _csi_boolean_var_; \ | | | | 118| 198|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 198] | | ------------------ ------------------ 483| 0| longjmp (scan->jump_buffer, status); 484| | 485| 198| status = _csi_name_lookup (ctx, obj.datum.name, &obj); 486| 4.16k| } else { /* literal name */ 487| 4.16k| status = csi_name_new (ctx, &obj, s + 1, len - 1); 488| 4.16k| } 489| 4.36k| if (_csi_unlikely (status)) ------------------ | | 120| 4.36k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.36k| __extension__ ({ \ | | | | 112| 4.36k| int _csi_boolean_var_; \ | | | | 113| 4.36k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 8, False: 4.35k] | | | | ------------------ | | | | 114| 4.36k| _csi_boolean_var_ = 1; \ | | | | 115| 4.36k| else \ | | | | 116| 4.36k| _csi_boolean_var_ = 0; \ | | | | 117| 4.36k| _csi_boolean_var_; \ | | | | 118| 4.36k|}) | | ------------------ | | | Branch (120:29): [True: 8, False: 4.35k] | | ------------------ ------------------ 490| 8| longjmp (scan->jump_buffer, status); 491| 4.53M| } else { 492| 4.53M| if (! _csi_parse_number (&obj, s, len)) { ------------------ | Branch (492:6): [True: 4.31M, False: 218k] ------------------ 493| 4.31M| status = csi_name_new (ctx, &obj, s, len); 494| 4.31M| if (_csi_unlikely (status)) ------------------ | | 120| 4.31M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.31M| __extension__ ({ \ | | | | 112| 4.31M| int _csi_boolean_var_; \ | | | | 113| 4.31M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4.31M] | | | | ------------------ | | | | 114| 4.31M| _csi_boolean_var_ = 1; \ | | | | 115| 4.31M| else \ | | | | 116| 4.31M| _csi_boolean_var_ = 0; \ | | | | 117| 4.31M| _csi_boolean_var_; \ | | | | 118| 4.31M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4.31M] | | ------------------ ------------------ 495| 0| longjmp (scan->jump_buffer, status); 496| | 497| 4.31M| obj.type |= CSI_OBJECT_ATTR_EXECUTABLE; 498| 4.31M| } 499| 4.53M| } 500| | 501| | /* consume whitespace after token, before calling the interpreter */ 502| 4.53M| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) { ------------------ | Branch (502:9): [True: 822k, False: 3.71M] ------------------ 503| 822k| status = csi_array_append (ctx, 504| 822k| scan->build_procedure.datum.array, 505| 822k| &obj); 506| 3.71M| } else if (obj.type & CSI_OBJECT_ATTR_EXECUTABLE) { ------------------ | Branch (506:16): [True: 3.49M, False: 217k] ------------------ 507| 3.49M| status = scan_execute (ctx, &obj); 508| 3.49M| csi_object_free (ctx, &obj); 509| 3.49M| } else { 510| 217k| status = scan_push (ctx, &obj); 511| 217k| } 512| 4.53M| if (_csi_unlikely (status)) ------------------ | | 120| 4.53M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.53M| __extension__ ({ \ | | | | 112| 4.53M| int _csi_boolean_var_; \ | | | | 113| 4.53M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 905, False: 4.53M] | | | | ------------------ | | | | 114| 4.53M| _csi_boolean_var_ = 1; \ | | | | 115| 4.53M| else \ | | | | 116| 4.53M| _csi_boolean_var_ = 0; \ | | | | 117| 4.53M| _csi_boolean_var_; \ | | | | 118| 4.53M|}) | | ------------------ | | | Branch (120:29): [True: 905, False: 4.53M] | | ------------------ ------------------ 513| 905| longjmp (scan->jump_buffer, status); 514| 4.53M|} cairo-script-scanner.c:scan_read: 781| 1.33M|{ 782| 1.33M| uint8_t *data = ptr; 783| 1.33M| do { 784| 1.33M| int ret = csi_file_read (src, data, len); 785| 1.33M| if (_csi_unlikely (ret == 0)) ------------------ | | 120| 1.33M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.33M| __extension__ ({ \ | | | | 112| 1.33M| int _csi_boolean_var_; \ | | | | 113| 1.33M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 506, False: 1.33M] | | | | ------------------ | | | | 114| 1.33M| _csi_boolean_var_ = 1; \ | | | | 115| 1.33M| else \ | | | | 116| 1.33M| _csi_boolean_var_ = 0; \ | | | | 117| 1.33M| _csi_boolean_var_; \ | | | | 118| 1.33M|}) | | ------------------ | | | Branch (120:29): [True: 506, False: 1.33M] | | ------------------ ------------------ 786| 506| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_READ_ERROR)); 787| 1.33M| data += ret; 788| 1.33M| len -= ret; 789| 1.33M| } while (_csi_unlikely (len)); ------------------ | | 120| 1.33M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.33M| __extension__ ({ \ | | | | 112| 1.33M| int _csi_boolean_var_; \ | | | | 113| 1.33M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 270, False: 1.33M] | | | | ------------------ | | | | 114| 1.33M| _csi_boolean_var_ = 1; \ | | | | 115| 1.33M| else \ | | | | 116| 1.33M| _csi_boolean_var_ = 0; \ | | | | 117| 1.33M| _csi_boolean_var_; \ | | | | 118| 1.33M|}) | | ------------------ | | | Branch (120:29): [True: 270, False: 1.33M] | | ------------------ ------------------ 790| 1.33M|} cairo-script-scanner.c:string_read: 799| 3.73k|{ 800| 3.73k| csi_status_t status; 801| | 802| 3.73k| status = csi_string_new (ctx, obj, NULL, len); 803| 3.73k| if (_csi_unlikely (status)) ------------------ | | 120| 3.73k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.73k| __extension__ ({ \ | | | | 112| 3.73k| int _csi_boolean_var_; \ | | | | 113| 3.73k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 3.73k] | | | | ------------------ | | | | 114| 3.73k| _csi_boolean_var_ = 1; \ | | | | 115| 3.73k| else \ | | | | 116| 3.73k| _csi_boolean_var_ = 0; \ | | | | 117| 3.73k| _csi_boolean_var_; \ | | | | 118| 3.73k|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 3.73k] | | ------------------ ------------------ 804| 1| longjmp (scan->jump_buffer, status); 805| | 806| 3.73k| if (compressed) { ------------------ | Branch (806:9): [True: 2.42k, False: 1.31k] ------------------ 807| 2.42k| uint32_t u32; 808| 2.42k| scan_read (scan, src, &u32, 4); 809| 2.42k| obj->datum.string->deflate = be32 (u32); ------------------ | | 64| 2.42k|#define be32(x) bswap_32 (x) ------------------ 810| 2.42k| obj->datum.string->method = compressed; 811| 2.42k| } 812| | 813| 3.73k| if (_csi_likely (len)) ------------------ | | 119| 3.73k|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 3.73k| __extension__ ({ \ | | | | 112| 3.73k| int _csi_boolean_var_; \ | | | | 113| 3.73k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 2.16k, False: 1.57k] | | | | ------------------ | | | | 114| 3.73k| _csi_boolean_var_ = 1; \ | | | | 115| 3.73k| else \ | | | | 116| 3.73k| _csi_boolean_var_ = 0; \ | | | | 117| 3.73k| _csi_boolean_var_; \ | | | | 118| 3.73k|}) | | ------------------ | | | Branch (119:27): [True: 2.16k, False: 1.57k] | | ------------------ ------------------ 814| 2.16k| scan_read (scan, src, obj->datum.string->string, len); 815| 3.73k| obj->datum.string->string[len] = '\0'; 816| 3.73k|} cairo-script-scanner.c:hex_value: 548| 2.24M|{ 549| 2.24M| if (c < '0') ------------------ | Branch (549:9): [True: 2.14k, False: 2.24M] ------------------ 550| 2.14k| return EOF; 551| 2.24M| if (c <= '9') ------------------ | Branch (551:9): [True: 187k, False: 2.05M] ------------------ 552| 187k| return c - '0'; 553| 2.05M| c |= 32; 554| 2.05M| if (c < 'a') ------------------ | Branch (554:9): [True: 10.1k, False: 2.04M] ------------------ 555| 10.1k| return EOF; 556| 2.04M| if (c <= 'f') ------------------ | Branch (556:9): [True: 2.03M, False: 3.02k] ------------------ 557| 2.03M| return c - 'a' + 0xa; 558| 3.02k| return EOF; 559| 2.04M|} cairo-script-scanner.c:scan_execute: 166| 4.02M|{ 167| 4.02M| return ctx->scanner.execute (ctx, obj); 168| 4.02M|} cairo-script-scanner.c:scan_push: 160| 1.19M|{ 161| 1.19M| return ctx->scanner.push (ctx, obj); 162| 1.19M|} cairo-script-scanner.c:token_add: 243| 21.4M|{ 244| 21.4M| buffer_check (ctx, scan, 1); 245| 21.4M| buffer_add (&scan->buffer, c); 246| 21.4M|} cairo-script-scanner.c:buffer_check: 218| 28.5M|{ 219| 28.5M| if (_csi_unlikely (scan->buffer.ptr + count > scan->buffer.end)) ------------------ | | 120| 28.5M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 28.5M| __extension__ ({ \ | | | | 112| 28.5M| int _csi_boolean_var_; \ | | | | 113| 28.5M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 364, False: 28.5M] | | | | ------------------ | | | | 114| 28.5M| _csi_boolean_var_ = 1; \ | | | | 115| 28.5M| else \ | | | | 116| 28.5M| _csi_boolean_var_ = 0; \ | | | | 117| 28.5M| _csi_boolean_var_; \ | | | | 118| 28.5M|}) | | ------------------ | | | Branch (120:29): [True: 364, False: 28.5M] | | ------------------ ------------------ 220| 364| _buffer_grow (ctx, scan); 221| 28.5M|} cairo-script-scanner.c:_buffer_grow: 196| 364|{ 197| 364| int newsize; 198| 364| int offset; 199| 364| char *base; 200| | 201| 364| if (_csi_unlikely (scan->buffer.size > INT_MAX / 2)) ------------------ | | 120| 364|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 364| __extension__ ({ \ | | | | 112| 364| int _csi_boolean_var_; \ | | | | 113| 364| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 364] | | | | ------------------ | | | | 114| 364| _csi_boolean_var_ = 1; \ | | | | 115| 364| else \ | | | | 116| 364| _csi_boolean_var_ = 0; \ | | | | 117| 364| _csi_boolean_var_; \ | | | | 118| 364|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 364] | | ------------------ ------------------ 202| 0| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_NO_MEMORY)); 203| | 204| 364| offset = scan->buffer.ptr - scan->buffer.base; 205| 364| newsize = scan->buffer.size * 2; 206| 364| base = _csi_realloc (ctx, scan->buffer.base, newsize); 207| 364| if (_csi_unlikely (base == NULL)) ------------------ | | 120| 364|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 364| __extension__ ({ \ | | | | 112| 364| int _csi_boolean_var_; \ | | | | 113| 364| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 364] | | | | ------------------ | | | | 114| 364| _csi_boolean_var_ = 1; \ | | | | 115| 364| else \ | | | | 116| 364| _csi_boolean_var_ = 0; \ | | | | 117| 364| _csi_boolean_var_; \ | | | | 118| 364|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 364] | | ------------------ ------------------ 208| 0| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_NO_MEMORY)); 209| | 210| 364| scan->buffer.base = base; 211| 364| scan->buffer.ptr = base + offset; 212| 364| scan->buffer.end = base + newsize; 213| 364| scan->buffer.size = newsize; 214| 364|} cairo-script-scanner.c:buffer_reset: 231| 5.57M|{ 232| 5.57M| buffer->ptr = buffer->base; 233| 5.57M|} cairo-script-scanner.c:string_add: 518| 5.56M|{ 519| 5.56M| buffer_check (ctx, scan, 1); 520| 5.56M| buffer_add (&scan->buffer, c); 521| 5.56M|} cairo-script-scanner.c:string_end: 525| 4.81k|{ 526| 4.81k| csi_object_t obj; 527| 4.81k| cairo_status_t status; 528| | 529| 4.81k| status = csi_string_new (ctx, 530| 4.81k| &obj, 531| 4.81k| scan->buffer.base, 532| 4.81k| scan->buffer.ptr - scan->buffer.base); 533| 4.81k| if (_csi_unlikely (status)) ------------------ | | 120| 4.81k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.81k| __extension__ ({ \ | | | | 112| 4.81k| int _csi_boolean_var_; \ | | | | 113| 4.81k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4.81k] | | | | ------------------ | | | | 114| 4.81k| _csi_boolean_var_ = 1; \ | | | | 115| 4.81k| else \ | | | | 116| 4.81k| _csi_boolean_var_ = 0; \ | | | | 117| 4.81k| _csi_boolean_var_; \ | | | | 118| 4.81k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4.81k] | | ------------------ ------------------ 534| 0| longjmp (scan->jump_buffer, status); 535| | 536| 4.81k| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) ------------------ | Branch (536:9): [True: 4.16k, False: 648] ------------------ 537| 4.16k| status = csi_array_append (ctx, 538| 4.16k| scan->build_procedure.datum.array, 539| 4.16k| &obj); 540| 648| else 541| 648| status = scan_push (ctx, &obj); 542| 4.81k| if (_csi_unlikely (status)) ------------------ | | 120| 4.81k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 4.81k| __extension__ ({ \ | | | | 112| 4.81k| int _csi_boolean_var_; \ | | | | 113| 4.81k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 4.81k] | | | | ------------------ | | | | 114| 4.81k| _csi_boolean_var_ = 1; \ | | | | 115| 4.81k| else \ | | | | 116| 4.81k| _csi_boolean_var_ = 0; \ | | | | 117| 4.81k| _csi_boolean_var_; \ | | | | 118| 4.81k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 4.81k] | | ------------------ ------------------ 543| 0| longjmp (scan->jump_buffer, status); 544| 4.81k|} cairo-script-scanner.c:hex_end: 579| 195k|{ 580| 195k| csi_object_t obj; 581| 195k| cairo_status_t status; 582| | 583| 195k| if (scan->accumulator_count) ------------------ | Branch (583:9): [True: 176k, False: 18.7k] ------------------ 584| 176k| hex_add (ctx, scan, '0'); 585| | 586| 195k| status = csi_string_new (ctx, 587| 195k| &obj, 588| 195k| scan->buffer.base, 589| 195k| scan->buffer.ptr - scan->buffer.base); 590| 195k| if (_csi_unlikely (status)) ------------------ | | 120| 195k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 195k| __extension__ ({ \ | | | | 112| 195k| int _csi_boolean_var_; \ | | | | 113| 195k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 195k] | | | | ------------------ | | | | 114| 195k| _csi_boolean_var_ = 1; \ | | | | 115| 195k| else \ | | | | 116| 195k| _csi_boolean_var_ = 0; \ | | | | 117| 195k| _csi_boolean_var_; \ | | | | 118| 195k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 195k] | | ------------------ ------------------ 591| 0| longjmp (scan->jump_buffer, status); 592| | 593| 195k| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) ------------------ | Branch (593:9): [True: 8.90k, False: 186k] ------------------ 594| 8.90k| status = csi_array_append (ctx, 595| 8.90k| scan->build_procedure.datum.array, 596| 8.90k| &obj); 597| 186k| else 598| 186k| status = scan_push (ctx, &obj); 599| 195k| if (_csi_unlikely (status)) ------------------ | | 120| 195k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 195k| __extension__ ({ \ | | | | 112| 195k| int _csi_boolean_var_; \ | | | | 113| 195k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 195k] | | | | ------------------ | | | | 114| 195k| _csi_boolean_var_ = 1; \ | | | | 115| 195k| else \ | | | | 116| 195k| _csi_boolean_var_ = 0; \ | | | | 117| 195k| _csi_boolean_var_; \ | | | | 118| 195k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 195k] | | ------------------ ------------------ 600| 0| longjmp (scan->jump_buffer, status); 601| 195k|} cairo-script-scanner.c:hex_add: 563| 2.21M|{ 564| 2.21M| if (scan->accumulator_count == 0) { ------------------ | Branch (564:9): [True: 1.10M, False: 1.10M] ------------------ 565| 1.10M| scan->accumulator |= hex_value (c) << 4; 566| 1.10M| scan->accumulator_count = 1; 567| 1.10M| } else { 568| 1.10M| scan->accumulator |= hex_value (c) << 0; 569| 1.10M| buffer_check (ctx, scan, 1); 570| 1.10M| buffer_add (&scan->buffer, scan->accumulator); 571| | 572| 1.10M| scan->accumulator = 0; 573| 1.10M| scan->accumulator_count = 0; 574| 1.10M| } 575| 2.21M|} cairo-script-scanner.c:base85_end: 634| 1.01k|{ 635| 1.01k| csi_object_t obj; 636| 1.01k| cairo_status_t status; 637| | 638| 1.01k| buffer_check (ctx, scan, 4); 639| | 640| 1.01k| switch (scan->accumulator_count) { ------------------ | Branch (640:13): [True: 1.01k, False: 0] ------------------ 641| 231| case 0: ------------------ | Branch (641:5): [True: 231, False: 787] ------------------ 642| 231| break; 643| 2| case 1: ------------------ | Branch (643:5): [True: 2, False: 1.01k] ------------------ 644| 2| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 645| 0| break; 646| | 647| 387| case 2: ------------------ | Branch (647:5): [True: 387, False: 631] ------------------ 648| 387| scan->accumulator = scan->accumulator * (85*85*85) + 85*85*85 -1; 649| 387| buffer_add (&scan->buffer, (scan->accumulator >> 24) & 0xff); 650| 387| break; 651| 202| case 3: ------------------ | Branch (651:5): [True: 202, False: 816] ------------------ 652| 202| scan->accumulator = scan->accumulator * (85*85) + 85*85 -1; 653| 202| buffer_add (&scan->buffer, (scan->accumulator >> 24) & 0xff); 654| 202| buffer_add (&scan->buffer, (scan->accumulator >> 16) & 0xff); 655| 202| break; 656| 196| case 4: ------------------ | Branch (656:5): [True: 196, False: 822] ------------------ 657| 196| scan->accumulator = scan->accumulator * 85 + 84; 658| 196| buffer_add (&scan->buffer, (scan->accumulator >> 24) & 0xff); 659| 196| buffer_add (&scan->buffer, (scan->accumulator >> 16) & 0xff); 660| 196| buffer_add (&scan->buffer, (scan->accumulator >> 8) & 0xff); 661| 196| break; 662| 1.01k| } 663| | 664| 1.01k| if (deflate) { ------------------ | Branch (664:9): [True: 349, False: 667] ------------------ 665| 349| uLongf len = be32 (*(uint32_t *) scan->buffer.base); ------------------ | | 64| 349|#define be32(x) bswap_32 (x) ------------------ 666| 349| Bytef *source = (Bytef *) (scan->buffer.base + sizeof (uint32_t)); 667| | 668| 349| status = csi_string_deflate_new (ctx, &obj, 669| 349| source, 670| 349| (Bytef *) scan->buffer.ptr - source, 671| 349| len); 672| 349| if (_csi_unlikely (status)) ------------------ | | 120| 349|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 349| __extension__ ({ \ | | | | 112| 349| int _csi_boolean_var_; \ | | | | 113| 349| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 349] | | | | ------------------ | | | | 114| 349| _csi_boolean_var_ = 1; \ | | | | 115| 349| else \ | | | | 116| 349| _csi_boolean_var_ = 0; \ | | | | 117| 349| _csi_boolean_var_; \ | | | | 118| 349|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 349] | | ------------------ ------------------ 673| 0| longjmp (scan->jump_buffer, status); 674| 667| } else { 675| 667| status = csi_string_new (ctx, 676| 667| &obj, 677| 667| scan->buffer.base, 678| 667| scan->buffer.ptr - scan->buffer.base); 679| 667| if (_csi_unlikely (status)) ------------------ | | 120| 667|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 667| __extension__ ({ \ | | | | 112| 667| int _csi_boolean_var_; \ | | | | 113| 667| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 667] | | | | ------------------ | | | | 114| 667| _csi_boolean_var_ = 1; \ | | | | 115| 667| else \ | | | | 116| 667| _csi_boolean_var_ = 0; \ | | | | 117| 667| _csi_boolean_var_; \ | | | | 118| 667|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 667] | | ------------------ ------------------ 680| 0| longjmp (scan->jump_buffer, status); 681| 667| } 682| | 683| 1.01k| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) ------------------ | Branch (683:9): [True: 195, False: 821] ------------------ 684| 195| status = csi_array_append (ctx, 685| 195| scan->build_procedure.datum.array, 686| 195| &obj); 687| 821| else 688| 821| status = scan_push (ctx, &obj); 689| 1.01k| if (_csi_unlikely (status)) ------------------ | | 120| 1.01k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.01k| __extension__ ({ \ | | | | 112| 1.01k| int _csi_boolean_var_; \ | | | | 113| 1.01k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.01k] | | | | ------------------ | | | | 114| 1.01k| _csi_boolean_var_ = 1; \ | | | | 115| 1.01k| else \ | | | | 116| 1.01k| _csi_boolean_var_ = 0; \ | | | | 117| 1.01k| _csi_boolean_var_; \ | | | | 118| 1.01k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.01k] | | ------------------ ------------------ 690| 0| longjmp (scan->jump_buffer, status); 691| 1.01k|} cairo-script-scanner.c:base85_add: 605| 721k|{ 606| 721k| if (c == 'z') { ------------------ | Branch (606:9): [True: 724, False: 720k] ------------------ 607| 724| if (_csi_unlikely (scan->accumulator_count != 0)) ------------------ | | 120| 724|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 724| __extension__ ({ \ | | | | 112| 724| int _csi_boolean_var_; \ | | | | 113| 724| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 1, False: 723] | | | | ------------------ | | | | 114| 724| _csi_boolean_var_ = 1; \ | | | | 115| 724| else \ | | | | 116| 724| _csi_boolean_var_ = 0; \ | | | | 117| 724| _csi_boolean_var_; \ | | | | 118| 724|}) | | ------------------ | | | Branch (120:29): [True: 1, False: 723] | | ------------------ ------------------ 608| 1| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 609| | 610| 723| buffer_check (ctx, scan, 4); 611| 723| buffer_add (&scan->buffer, 0); 612| 723| buffer_add (&scan->buffer, 0); 613| 723| buffer_add (&scan->buffer, 0); 614| 723| buffer_add (&scan->buffer, 0); 615| 720k| } else if (_csi_unlikely (c < '!' || c > 'u')) { ------------------ | | 120| 720k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 720k| __extension__ ({ \ | | | | 112| 720k| int _csi_boolean_var_; \ | | | | 113| 2.16M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 5, False: 720k] | | | | | Branch (113:8): [True: 23, False: 720k] | | | | ------------------ | | | | 114| 720k| _csi_boolean_var_ = 1; \ | | | | 115| 720k| else \ | | | | 116| 720k| _csi_boolean_var_ = 0; \ | | | | 117| 720k| _csi_boolean_var_; \ | | | | 118| 720k|}) | | ------------------ | | | Branch (120:29): [True: 28, False: 720k] | | ------------------ ------------------ 616| 28| longjmp (scan->jump_buffer, _csi_error (CSI_STATUS_INVALID_SCRIPT)); 617| 720k| } else { 618| 720k| scan->accumulator = scan->accumulator*85 + c - '!'; 619| 720k| if (++scan->accumulator_count == 5) { ------------------ | Branch (619:6): [True: 143k, False: 576k] ------------------ 620| 143k| buffer_check (ctx, scan, 4); 621| 143k| buffer_add (&scan->buffer, (scan->accumulator >> 24) & 0xff); 622| 143k| buffer_add (&scan->buffer, (scan->accumulator >> 16) & 0xff); 623| 143k| buffer_add (&scan->buffer, (scan->accumulator >> 8) & 0xff); 624| 143k| buffer_add (&scan->buffer, (scan->accumulator >> 0) & 0xff); 625| | 626| 143k| scan->accumulator = 0; 627| 143k| scan->accumulator_count = 0; 628| 143k| } 629| 720k| } 630| 721k|} cairo-script-scanner.c:base64_end: 744| 1.50k|{ 745| 1.50k| csi_object_t obj; 746| 1.50k| cairo_status_t status; 747| | 748| 1.50k| switch (scan->accumulator_count) { ------------------ | Branch (748:13): [True: 1.15k, False: 347] ------------------ 749| 90| case 0: ------------------ | Branch (749:5): [True: 90, False: 1.41k] ------------------ 750| 90| break; 751| 556| case 2: ------------------ | Branch (751:5): [True: 556, False: 944] ------------------ 752| 556| base64_add (ctx, scan, (scan->accumulator << 2) & 0x3f); 753| 556| base64_add (ctx, scan, '='); 754| 556| break; 755| 507| case 1: ------------------ | Branch (755:5): [True: 507, False: 993] ------------------ 756| 507| base64_add (ctx, scan, (scan->accumulator << 4) & 0x3f); 757| 507| base64_add (ctx, scan, '='); 758| 507| base64_add (ctx, scan, '='); 759| 507| break; 760| 1.50k| } 761| | 762| 1.50k| status = csi_string_new (ctx, 763| 1.50k| &obj, 764| 1.50k| scan->buffer.base, 765| 1.50k| scan->buffer.ptr - scan->buffer.base); 766| 1.50k| if (_csi_unlikely (status)) ------------------ | | 120| 1.50k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.50k| __extension__ ({ \ | | | | 112| 1.50k| int _csi_boolean_var_; \ | | | | 113| 1.50k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.50k] | | | | ------------------ | | | | 114| 1.50k| _csi_boolean_var_ = 1; \ | | | | 115| 1.50k| else \ | | | | 116| 1.50k| _csi_boolean_var_ = 0; \ | | | | 117| 1.50k| _csi_boolean_var_; \ | | | | 118| 1.50k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.50k] | | ------------------ ------------------ 767| 0| longjmp (scan->jump_buffer, status); 768| | 769| 1.50k| if (scan->build_procedure.type != CSI_OBJECT_TYPE_NULL) ------------------ | Branch (769:9): [True: 688, False: 812] ------------------ 770| 688| status = csi_array_append (ctx, 771| 688| scan->build_procedure.datum.array, 772| 688| &obj); 773| 812| else 774| 812| status = scan_push (ctx, &obj); 775| 1.50k| if (_csi_unlikely (status)) ------------------ | | 120| 1.50k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.50k| __extension__ ({ \ | | | | 112| 1.50k| int _csi_boolean_var_; \ | | | | 113| 1.50k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.50k] | | | | ------------------ | | | | 114| 1.50k| _csi_boolean_var_ = 1; \ | | | | 115| 1.50k| else \ | | | | 116| 1.50k| _csi_boolean_var_ = 0; \ | | | | 117| 1.50k| _csi_boolean_var_; \ | | | | 118| 1.50k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.50k] | | ------------------ ------------------ 776| 0| longjmp (scan->jump_buffer, status); 777| 1.50k|} cairo-script-scanner.c:base64_add: 695| 340k|{ 696| 340k| int val; 697| | 698| | /* Convert Base64 character to its 6 bit nibble */ 699| 340k| val = scan->accumulator; 700| 340k| if (c =='/') { ------------------ | Branch (700:9): [True: 511, False: 340k] ------------------ 701| 511| val = (val << 6) | 63; 702| 340k| } else if (c =='+') { ------------------ | Branch (702:16): [True: 980, False: 339k] ------------------ 703| 980| val = (val << 6) | 62; 704| 339k| } else if (c >='A' && c <='Z') { ------------------ | Branch (704:16): [True: 181k, False: 157k] | Branch (704:27): [True: 1.83k, False: 179k] ------------------ 705| 1.83k| val = (val << 6) | (c -'A'); 706| 337k| } else if (c >='a' && c <='z') { ------------------ | Branch (706:16): [True: 177k, False: 160k] | Branch (706:27): [True: 92.3k, False: 84.6k] ------------------ 707| 92.3k| val = (val << 6) | (c -'a' + 26); 708| 245k| } else if (c >='0' && c <='9') { ------------------ | Branch (708:16): [True: 229k, False: 15.3k] | Branch (708:27): [True: 2.01k, False: 227k] ------------------ 709| 2.01k| val = (val << 6) | (c -'0' + 52); 710| 2.01k| } 711| | 712| 340k| buffer_check (ctx, scan, 1); 713| 340k| switch (scan->accumulator_count++) { ------------------ | Branch (713:13): [True: 340k, False: 0] ------------------ 714| 86.6k| case 0: ------------------ | Branch (714:5): [True: 86.6k, False: 254k] ------------------ 715| 86.6k| break; 716| | 717| 85.3k| case 1: ------------------ | Branch (717:5): [True: 85.3k, False: 255k] ------------------ 718| 85.3k| buffer_add (&scan->buffer, (val >> 4) & 0xFF); 719| 85.3k| val &= 0xF; 720| 85.3k| break; 721| | 722| 85.1k| case 2: ------------------ | Branch (722:5): [True: 85.1k, False: 255k] ------------------ 723| 85.1k| buffer_add (&scan->buffer, (val >> 2) & 0xFF); 724| 85.1k| val &= 0x3; 725| 85.1k| break; 726| | 727| 83.7k| case 3: ------------------ | Branch (727:5): [True: 83.7k, False: 257k] ------------------ 728| 83.7k| buffer_add (&scan->buffer, (val >> 0) & 0xFF); 729| 83.7k| scan->accumulator_count = 0; 730| 83.7k| val = 0; 731| 83.7k| break; 732| 340k| } 733| | 734| 340k| if (c == '=') { ------------------ | Branch (734:10): [True: 46.7k, False: 294k] ------------------ 735| 46.7k| scan->accumulator_count = 0; 736| 46.7k| scan->accumulator = 0; 737| 294k| } else { 738| 294k| scan->accumulator = val; 739| 294k| } 740| 340k|} _csi_stack_init: 44| 1.27M|{ 45| 1.27M| csi_status_t status = CSI_STATUS_SUCCESS; 46| | 47| 1.27M| stack->len = 0; 48| 1.27M| stack->size = size; 49| | /* assert ((unsigned) size < INT_MAX / sizeof (csi_object_t)); */ 50| 1.27M| stack->objects = _csi_alloc (ctx, size * sizeof (csi_object_t)); 51| 1.27M| if (_csi_unlikely (stack->objects == NULL)) ------------------ | | 120| 1.27M|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 1.27M| __extension__ ({ \ | | | | 112| 1.27M| int _csi_boolean_var_; \ | | | | 113| 1.27M| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 1.27M] | | | | ------------------ | | | | 114| 1.27M| _csi_boolean_var_ = 1; \ | | | | 115| 1.27M| else \ | | | | 116| 1.27M| _csi_boolean_var_ = 0; \ | | | | 117| 1.27M| _csi_boolean_var_; \ | | | | 118| 1.27M|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 1.27M] | | ------------------ ------------------ 52| 0| status = _csi_error (CSI_STATUS_NO_MEMORY); 53| | 54| 1.27M| return status; 55| 1.27M|} _csi_stack_fini: 59| 1.26M|{ 60| 1.26M| csi_integer_t n; 61| | 62| 5.84M| for (n = 0; n < stack->len; n++) ------------------ | Branch (62:17): [True: 4.57M, False: 1.26M] ------------------ 63| 4.57M| csi_object_free (ctx, &stack->objects[n]); 64| | 65| 1.26M| _csi_free (ctx, stack->objects); 66| 1.26M|} _csi_stack_roll: 72| 348|{ 73| 348| csi_object_t stack_copy[128]; 74| 348| csi_object_t *copy; 75| 348| csi_integer_t last, i, len; 76| | 77| 348| switch (mod) { /* special cases */ ------------------ | Branch (77:13): [True: 0, False: 348] ------------------ 78| 0| case 1: ------------------ | Branch (78:5): [True: 0, False: 348] ------------------ 79| 0| last = stack->len - 1; 80| 0| stack_copy[0] = stack->objects[last]; 81| 0| for (i = last; --n; i--) ------------------ | Branch (81:17): [True: 0, False: 0] ------------------ 82| 0| stack->objects[i] = stack->objects[i-1]; 83| 0| stack->objects[i] = stack_copy[0]; 84| 0| return CSI_STATUS_SUCCESS; 85| 0| case -1: ------------------ | Branch (85:5): [True: 0, False: 348] ------------------ 86| 0| last = stack->len - 1; 87| 0| stack_copy[0] = stack->objects[i = last - n + 1]; 88| 0| for (; --n; i++) ------------------ | Branch (88:9): [True: 0, False: 0] ------------------ 89| 0| stack->objects[i] = stack->objects[i+1]; 90| 0| stack->objects[i] = stack_copy[0]; 91| 0| return CSI_STATUS_SUCCESS; 92| 348| } 93| | 94| | /* fall back to a copy */ 95| 348| if (n > ARRAY_LENGTH (stack_copy)) { ------------------ | | 145| 348|#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0]))) ------------------ | Branch (95:9): [True: 0, False: 348] ------------------ 96| 0| if (_csi_unlikely ((unsigned) n > INT_MAX / sizeof (csi_object_t))) ------------------ | | 120| 0|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 0| __extension__ ({ \ | | | | 112| 0| int _csi_boolean_var_; \ | | | | 113| 0| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 0] | | | | ------------------ | | | | 114| 0| _csi_boolean_var_ = 1; \ | | | | 115| 0| else \ | | | | 116| 0| _csi_boolean_var_ = 0; \ | | | | 117| 0| _csi_boolean_var_; \ | | | | 118| 0|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 0] | | ------------------ ------------------ 97| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 98| 0| copy = _csi_alloc (ctx, n * sizeof (csi_object_t)); 99| 0| if (copy == NULL) ------------------ | Branch (99:6): [True: 0, False: 0] ------------------ 100| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 101| 0| } else 102| 348| copy = stack_copy; 103| | 104| 348| i = stack->len - n; 105| 348| memcpy (copy, stack->objects + i, n * sizeof (csi_object_t)); 106| 348| mod = -mod; 107| 348| if (mod < 0) ------------------ | Branch (107:9): [True: 3, False: 345] ------------------ 108| 3| mod += n; 109| 348| last = mod; 110| 354| for (len = n; n--; i++) { ------------------ | Branch (110:19): [True: 6, False: 348] ------------------ 111| 6| stack->objects[i] = copy[last]; 112| 6| if (++last == len) ------------------ | Branch (112:6): [True: 1, False: 5] ------------------ 113| 1| last = 0; 114| 6| } 115| | 116| 348| if (copy != stack_copy) ------------------ | Branch (116:9): [True: 0, False: 348] ------------------ 117| 0| _csi_free (ctx, copy); 118| | 119| 348| return CSI_STATUS_SUCCESS; 120| 348|} _csi_stack_grow: 124| 3.62k|{ 125| 3.62k| csi_integer_t newsize; 126| 3.62k| csi_object_t *newstack; 127| | 128| 3.62k| if (_csi_likely (cnt <= stack->size)) ------------------ | | 119| 3.62k|#define _csi_likely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 111| 3.62k| __extension__ ({ \ | | | | 112| 3.62k| int _csi_boolean_var_; \ | | | | 113| 3.62k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.62k] | | | | ------------------ | | | | 114| 3.62k| _csi_boolean_var_ = 1; \ | | | | 115| 3.62k| else \ | | | | 116| 3.62k| _csi_boolean_var_ = 0; \ | | | | 117| 3.62k| _csi_boolean_var_; \ | | | | 118| 3.62k|}) | | ------------------ | | | Branch (119:27): [True: 0, False: 3.62k] | | ------------------ ------------------ 129| 0| return CSI_STATUS_SUCCESS; 130| 3.62k| if (_csi_unlikely ((unsigned) cnt >= INT_MAX / sizeof (csi_object_t))) ------------------ | | 120| 3.62k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.62k| __extension__ ({ \ | | | | 112| 3.62k| int _csi_boolean_var_; \ | | | | 113| 3.62k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.62k] | | | | ------------------ | | | | 114| 3.62k| _csi_boolean_var_ = 1; \ | | | | 115| 3.62k| else \ | | | | 116| 3.62k| _csi_boolean_var_ = 0; \ | | | | 117| 3.62k| _csi_boolean_var_; \ | | | | 118| 3.62k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 3.62k] | | ------------------ ------------------ 131| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 132| | 133| 3.62k| newsize = stack->size; 134| 3.62k| do { 135| 3.62k| newsize *= 2; 136| 3.62k| } while (newsize <= cnt); ------------------ | Branch (136:14): [True: 0, False: 3.62k] ------------------ 137| | 138| 3.62k| newstack = _csi_realloc (ctx, 139| 3.62k| stack->objects, 140| 3.62k| newsize * sizeof (csi_object_t)); 141| 3.62k| if (_csi_unlikely (newstack == NULL)) ------------------ | | 120| 3.62k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.62k| __extension__ ({ \ | | | | 112| 3.62k| int _csi_boolean_var_; \ | | | | 113| 3.62k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.62k] | | | | ------------------ | | | | 114| 3.62k| _csi_boolean_var_ = 1; \ | | | | 115| 3.62k| else \ | | | | 116| 3.62k| _csi_boolean_var_ = 0; \ | | | | 117| 3.62k| _csi_boolean_var_; \ | | | | 118| 3.62k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 3.62k] | | ------------------ ------------------ 142| 0| return _csi_error (CSI_STATUS_NO_MEMORY); 143| | 144| 3.62k| stack->objects = newstack; 145| 3.62k| stack->size = newsize; 146| | 147| 3.62k| return CSI_STATUS_SUCCESS; 148| 3.62k|} _csi_stack_push_internal: 153| 3.62k|{ 154| 3.62k| csi_status_t status; 155| | 156| 3.62k| status = _csi_stack_grow (ctx, stack, stack->size + 1); 157| 3.62k| if (_csi_unlikely (status)) ------------------ | | 120| 3.62k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 3.62k| __extension__ ({ \ | | | | 112| 3.62k| int _csi_boolean_var_; \ | | | | 113| 3.62k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 3.62k] | | | | ------------------ | | | | 114| 3.62k| _csi_boolean_var_ = 1; \ | | | | 115| 3.62k| else \ | | | | 116| 3.62k| _csi_boolean_var_ = 0; \ | | | | 117| 3.62k| _csi_boolean_var_; \ | | | | 118| 3.62k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 3.62k] | | ------------------ ------------------ 158| 0| return status; 159| | 160| 3.62k| stack->objects[stack->len++] = *obj; 161| 3.62k| return CSI_STATUS_SUCCESS; 162| 3.62k|} _csi_stack_peek: 166| 8.36k|{ 167| 8.36k| if (_csi_unlikely (stack->len < i)) ------------------ | | 120| 8.36k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8.36k| __extension__ ({ \ | | | | 112| 8.36k| int _csi_boolean_var_; \ | | | | 113| 8.36k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 0, False: 8.36k] | | | | ------------------ | | | | 114| 8.36k| _csi_boolean_var_ = 1; \ | | | | 115| 8.36k| else \ | | | | 116| 8.36k| _csi_boolean_var_ = 0; \ | | | | 117| 8.36k| _csi_boolean_var_; \ | | | | 118| 8.36k|}) | | ------------------ | | | Branch (120:29): [True: 0, False: 8.36k] | | ------------------ ------------------ 168| 0| return NULL; 169| | 170| 8.36k| return &stack->objects[stack->len - i -1]; 171| 8.36k|} _csi_stack_exch: 185| 8.76k|{ 186| 8.76k| csi_object_t tmp; 187| 8.76k| csi_integer_t n; 188| | 189| 8.76k| if (_csi_unlikely (stack->len < 2)) ------------------ | | 120| 8.76k|#define _csi_unlikely(expr) (__builtin_expect (_CSI_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 111| 8.76k| __extension__ ({ \ | | | | 112| 8.76k| int _csi_boolean_var_; \ | | | | 113| 8.76k| if (expr) \ | | | | ------------------ | | | | | Branch (113:8): [True: 3, False: 8.76k] | | | | ------------------ | | | | 114| 8.76k| _csi_boolean_var_ = 1; \ | | | | 115| 8.76k| else \ | | | | 116| 8.76k| _csi_boolean_var_ = 0; \ | | | | 117| 8.76k| _csi_boolean_var_; \ | | | | 118| 8.76k|}) | | ------------------ | | | Branch (120:29): [True: 3, False: 8.76k] | | ------------------ ------------------ 190| 3| return _csi_error (CSI_STATUS_INVALID_SCRIPT); 191| | 192| 8.76k| n = stack->len - 1; 193| 8.76k| tmp = stack->objects[n]; 194| 8.76k| stack->objects[n] = stack->objects[n - 1]; 195| 8.76k| stack->objects[n - 1] = tmp; 196| | 197| 8.76k| return CSI_STATUS_SUCCESS; 198| 8.76k|} LLVMFuzzerTestOneInput: 33| 5.14k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 34| 5.14k| cairo_script_interpreter_t *csi; 35| 5.14k| const cairo_script_interpreter_hooks_t hooks = { 36| 5.14k| .surface_create = _surface_create 37| 5.14k| }; 38| | 39| 5.14k| if (size == 0) { ------------------ | Branch (39:9): [True: 0, False: 5.14k] ------------------ 40| 0| return 0; 41| 0| } 42| | 43| 5.14k| csi = cairo_script_interpreter_create(); 44| 5.14k| if (!csi) { ------------------ | Branch (44:9): [True: 0, False: 5.14k] ------------------ 45| 0| return 0; 46| 0| } 47| | 48| 5.14k| cairo_script_interpreter_install_hooks (csi, &hooks); 49| | 50| 5.14k| cairo_script_interpreter_feed_string(csi, (const char *)data, size); 51| | 52| 5.14k| cairo_script_interpreter_finish(csi); 53| 5.14k| cairo_script_interpreter_destroy(csi); 54| | 55| 5.14k| return 0; 56| 5.14k|}