LCOV - code coverage report
Current view: directory - gfx/cairo/cairo/src - cairo-wideint-private.h (source / functions) Found Hit Coverage
Test: app.info Lines: 6 0 0.0 %
Date: 2012-06-02 Functions: 2 0 0.0 %

       1                 : /* cairo - a vector graphics library with display and print output
       2                 :  *
       3                 :  * Copyright © 2004 Keith Packard
       4                 :  *
       5                 :  * This library is free software; you can redistribute it and/or
       6                 :  * modify it either under the terms of the GNU Lesser General Public
       7                 :  * License version 2.1 as published by the Free Software Foundation
       8                 :  * (the "LGPL") or, at your option, under the terms of the Mozilla
       9                 :  * Public License Version 1.1 (the "MPL"). If you do not alter this
      10                 :  * notice, a recipient may use your version of this file under either
      11                 :  * the MPL or the LGPL.
      12                 :  *
      13                 :  * You should have received a copy of the LGPL along with this library
      14                 :  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
      15                 :  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
      16                 :  * You should have received a copy of the MPL along with this library
      17                 :  * in the file COPYING-MPL-1.1
      18                 :  *
      19                 :  * The contents of this file are subject to the Mozilla Public License
      20                 :  * Version 1.1 (the "License"); you may not use this file except in
      21                 :  * compliance with the License. You may obtain a copy of the License at
      22                 :  * http://www.mozilla.org/MPL/
      23                 :  *
      24                 :  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
      25                 :  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
      26                 :  * the specific language governing rights and limitations.
      27                 :  *
      28                 :  * The Original Code is the cairo graphics library.
      29                 :  *
      30                 :  * The Initial Developer of the Original Code is Keith Packard
      31                 :  *
      32                 :  * Contributor(s):
      33                 :  *      Keith R. Packard <keithp@keithp.com>
      34                 :  *
      35                 :  */
      36                 : 
      37                 : #ifndef CAIRO_WIDEINT_H
      38                 : #define CAIRO_WIDEINT_H
      39                 : 
      40                 : #include "cairo-wideint-type-private.h"
      41                 : 
      42                 : #include "cairo-compiler-private.h"
      43                 : 
      44                 : /*
      45                 :  * 64-bit datatypes.  Two separate implementations, one using
      46                 :  * built-in 64-bit signed/unsigned types another implemented
      47                 :  * as a pair of 32-bit ints
      48                 :  */
      49                 : 
      50                 : #define I cairo_private cairo_const
      51                 : 
      52                 : #if !HAVE_UINT64_T
      53                 : 
      54                 : cairo_uquorem64_t I
      55                 : _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den);
      56                 : 
      57                 : cairo_uint64_t I        _cairo_uint32_to_uint64 (uint32_t i);
      58                 : #define                 _cairo_uint64_to_uint32(a)  ((a).lo)
      59                 : cairo_uint64_t I        _cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
      60                 : cairo_uint64_t I        _cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
      61                 : cairo_uint64_t I        _cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
      62                 : cairo_uint64_t I        _cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
      63                 : cairo_uint64_t I        _cairo_uint64_lsl (cairo_uint64_t a, int shift);
      64                 : cairo_uint64_t I        _cairo_uint64_rsl (cairo_uint64_t a, int shift);
      65                 : cairo_uint64_t I        _cairo_uint64_rsa (cairo_uint64_t a, int shift);
      66                 : int            I        _cairo_uint64_lt (cairo_uint64_t a, cairo_uint64_t b);
      67                 : int            I        _cairo_uint64_cmp (cairo_uint64_t a, cairo_uint64_t b);
      68                 : int            I        _cairo_uint64_eq (cairo_uint64_t a, cairo_uint64_t b);
      69                 : cairo_uint64_t I        _cairo_uint64_negate (cairo_uint64_t a);
      70                 : #define                 _cairo_uint64_is_zero(a) ((a).hi == 0 && (a).lo == 0)
      71                 : #define                 _cairo_uint64_negative(a)   (((int32_t) ((a).hi)) < 0)
      72                 : cairo_uint64_t I        _cairo_uint64_not (cairo_uint64_t a);
      73                 : 
      74                 : #define                 _cairo_uint64_to_int64(i)   (i)
      75                 : #define                 _cairo_int64_to_uint64(i)   (i)
      76                 : 
      77                 : cairo_int64_t  I        _cairo_int32_to_int64(int32_t i);
      78                 : #define                 _cairo_int64_to_int32(a)    ((int32_t) _cairo_uint64_to_uint32(a))
      79                 : #define                 _cairo_int64_add(a,b)       _cairo_uint64_add (a,b)
      80                 : #define                 _cairo_int64_sub(a,b)       _cairo_uint64_sub (a,b)
      81                 : #define                 _cairo_int64_mul(a,b)       _cairo_uint64_mul (a,b)
      82                 : cairo_int64_t  I        _cairo_int32x32_64_mul (int32_t a, int32_t b);
      83                 : int            I        _cairo_int64_lt (cairo_int64_t a, cairo_int64_t b);
      84                 : int            I        _cairo_int64_cmp (cairo_int64_t a, cairo_int64_t b);
      85                 : #define                 _cairo_int64_is_zero(a)     _cairo_uint64_is_zero (a)
      86                 : #define                 _cairo_int64_eq(a,b)        _cairo_uint64_eq (a,b)
      87                 : #define                 _cairo_int64_lsl(a,b)       _cairo_uint64_lsl (a,b)
      88                 : #define                 _cairo_int64_rsl(a,b)       _cairo_uint64_rsl (a,b)
      89                 : #define                 _cairo_int64_rsa(a,b)       _cairo_uint64_rsa (a,b)
      90                 : #define                 _cairo_int64_negate(a)      _cairo_uint64_negate(a)
      91                 : #define                 _cairo_int64_negative(a)    (((int32_t) ((a).hi)) < 0)
      92                 : #define                 _cairo_int64_not(a)         _cairo_uint64_not(a)
      93                 : 
      94                 : #else
      95                 : 
      96                 : static inline cairo_uquorem64_t
      97               0 : _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den)
      98                 : {
      99                 :     cairo_uquorem64_t   qr;
     100                 : 
     101               0 :     qr.quo = num / den;
     102               0 :     qr.rem = num % den;
     103               0 :     return qr;
     104                 : }
     105                 : 
     106                 : #define                 _cairo_uint32_to_uint64(i)  ((uint64_t) (i))
     107                 : #define                 _cairo_uint64_to_uint32(i)  ((uint32_t) (i))
     108                 : #define                 _cairo_uint64_add(a,b)      ((a) + (b))
     109                 : #define                 _cairo_uint64_sub(a,b)      ((a) - (b))
     110                 : #define                 _cairo_uint64_mul(a,b)      ((a) * (b))
     111                 : #define                 _cairo_uint32x32_64_mul(a,b)    ((uint64_t) (a) * (b))
     112                 : #define                 _cairo_uint64_lsl(a,b)      ((a) << (b))
     113                 : #define                 _cairo_uint64_rsl(a,b)      ((uint64_t) (a) >> (b))
     114                 : #define                 _cairo_uint64_rsa(a,b)      ((uint64_t) ((int64_t) (a) >> (b)))
     115                 : #define                 _cairo_uint64_lt(a,b)       ((a) < (b))
     116                 : #define                 _cairo_uint64_cmp(a,b)       ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
     117                 : #define                 _cairo_uint64_is_zero(a)    ((a) == 0)
     118                 : #define                 _cairo_uint64_eq(a,b)       ((a) == (b))
     119                 : #define                 _cairo_uint64_negate(a)     ((uint64_t) -((int64_t) (a)))
     120                 : #define                 _cairo_uint64_negative(a)   ((int64_t) (a) < 0)
     121                 : #define                 _cairo_uint64_not(a)        (~(a))
     122                 : 
     123                 : #define                 _cairo_uint64_to_int64(i)   ((int64_t) (i))
     124                 : #define                 _cairo_int64_to_uint64(i)   ((uint64_t) (i))
     125                 : 
     126                 : #define                 _cairo_int32_to_int64(i)    ((int64_t) (i))
     127                 : #define                 _cairo_int64_to_int32(i)    ((int32_t) (i))
     128                 : #define                 _cairo_int64_add(a,b)       ((a) + (b))
     129                 : #define                 _cairo_int64_sub(a,b)       ((a) - (b))
     130                 : #define                 _cairo_int64_mul(a,b)       ((a) * (b))
     131                 : #define                 _cairo_int32x32_64_mul(a,b) ((int64_t) (a) * (b))
     132                 : #define                 _cairo_int64_lt(a,b)        ((a) < (b))
     133                 : #define                 _cairo_int64_cmp(a,b)       ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
     134                 : #define                 _cairo_int64_is_zero(a)     ((a) == 0)
     135                 : #define                 _cairo_int64_eq(a,b)        ((a) == (b))
     136                 : #define                 _cairo_int64_lsl(a,b)       ((a) << (b))
     137                 : #define                 _cairo_int64_rsl(a,b)       ((int64_t) ((uint64_t) (a) >> (b)))
     138                 : #define                 _cairo_int64_rsa(a,b)       ((int64_t) (a) >> (b))
     139                 : #define                 _cairo_int64_negate(a)      (-(a))
     140                 : #define                 _cairo_int64_negative(a)    ((a) < 0)
     141                 : #define                 _cairo_int64_not(a)         (~(a))
     142                 : 
     143                 : #endif
     144                 : 
     145                 : /*
     146                 :  * 64-bit comparisions derived from lt or eq
     147                 :  */
     148                 : #define                 _cairo_uint64_le(a,b)       (!_cairo_uint64_gt(a,b))
     149                 : #define                 _cairo_uint64_ne(a,b)       (!_cairo_uint64_eq(a,b))
     150                 : #define                 _cairo_uint64_ge(a,b)       (!_cairo_uint64_lt(a,b))
     151                 : #define                 _cairo_uint64_gt(a,b)       _cairo_uint64_lt(b,a)
     152                 : 
     153                 : #define                 _cairo_int64_le(a,b)        (!_cairo_int64_gt(a,b))
     154                 : #define                 _cairo_int64_ne(a,b)        (!_cairo_int64_eq(a,b))
     155                 : #define                 _cairo_int64_ge(a,b)        (!_cairo_int64_lt(a,b))
     156                 : #define                 _cairo_int64_gt(a,b)        _cairo_int64_lt(b,a)
     157                 : 
     158                 : /*
     159                 :  * As the C implementation always computes both, create
     160                 :  * a function which returns both for the 'native' type as well
     161                 :  */
     162                 : 
     163                 : static inline cairo_quorem64_t
     164                 : _cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den)
     165                 : {
     166                 :     int                 num_neg = _cairo_int64_negative (num);
     167                 :     int                 den_neg = _cairo_int64_negative (den);
     168                 :     cairo_uquorem64_t   uqr;
     169                 :     cairo_quorem64_t    qr;
     170                 : 
     171                 :     if (num_neg)
     172                 :         num = _cairo_int64_negate (num);
     173                 :     if (den_neg)
     174                 :         den = _cairo_int64_negate (den);
     175                 :     uqr = _cairo_uint64_divrem (num, den);
     176                 :     if (num_neg)
     177                 :         qr.rem = _cairo_int64_negate (uqr.rem);
     178                 :     else
     179                 :         qr.rem = uqr.rem;
     180                 :     if (num_neg != den_neg)
     181                 :         qr.quo = (cairo_int64_t) _cairo_int64_negate (uqr.quo);
     182                 :     else
     183                 :         qr.quo = (cairo_int64_t) uqr.quo;
     184                 :     return qr;
     185                 : }
     186                 : 
     187                 : static inline int32_t
     188               0 : _cairo_int64_32_div (cairo_int64_t num, int32_t den)
     189                 : {
     190                 : #if !HAVE_UINT64_T
     191                 :     return _cairo_int64_to_int32
     192                 :         (_cairo_int64_divrem (num, _cairo_int32_to_int64 (den)).quo);
     193                 : #else
     194               0 :     return num / den;
     195                 : #endif
     196                 : }
     197                 : 
     198                 : /*
     199                 :  * 128-bit datatypes.  Again, provide two implementations in
     200                 :  * case the machine has a native 128-bit datatype.  GCC supports int128_t
     201                 :  * on ia64
     202                 :  */
     203                 : 
     204                 : #if !HAVE_UINT128_T
     205                 : 
     206                 : cairo_uint128_t I       _cairo_uint32_to_uint128 (uint32_t i);
     207                 : cairo_uint128_t I       _cairo_uint64_to_uint128 (cairo_uint64_t i);
     208                 : #define                 _cairo_uint128_to_uint64(a)     ((a).lo)
     209                 : #define                 _cairo_uint128_to_uint32(a)     _cairo_uint64_to_uint32(_cairo_uint128_to_uint64(a))
     210                 : cairo_uint128_t I       _cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
     211                 : cairo_uint128_t I       _cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
     212                 : cairo_uint128_t I       _cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
     213                 : cairo_uint128_t I       _cairo_uint64x64_128_mul (cairo_uint64_t a, cairo_uint64_t b);
     214                 : cairo_uint128_t I       _cairo_uint128_lsl (cairo_uint128_t a, int shift);
     215                 : cairo_uint128_t I       _cairo_uint128_rsl (cairo_uint128_t a, int shift);
     216                 : cairo_uint128_t I       _cairo_uint128_rsa (cairo_uint128_t a, int shift);
     217                 : int             I       _cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
     218                 : int             I       _cairo_uint128_cmp (cairo_uint128_t a, cairo_uint128_t b);
     219                 : int             I       _cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
     220                 : #define                 _cairo_uint128_is_zero(a) (_cairo_uint64_is_zero ((a).hi) && _cairo_uint64_is_zero ((a).lo))
     221                 : cairo_uint128_t I       _cairo_uint128_negate (cairo_uint128_t a);
     222                 : #define                 _cairo_uint128_negative(a)  (_cairo_uint64_negative(a.hi))
     223                 : cairo_uint128_t I       _cairo_uint128_not (cairo_uint128_t a);
     224                 : 
     225                 : #define                 _cairo_uint128_to_int128(i)     (i)
     226                 : #define                 _cairo_int128_to_uint128(i)     (i)
     227                 : 
     228                 : cairo_int128_t  I       _cairo_int32_to_int128 (int32_t i);
     229                 : cairo_int128_t  I       _cairo_int64_to_int128 (cairo_int64_t i);
     230                 : #define                 _cairo_int128_to_int64(a)   ((cairo_int64_t) (a).lo)
     231                 : #define                 _cairo_int128_to_int32(a)   _cairo_int64_to_int32(_cairo_int128_to_int64(a))
     232                 : #define                 _cairo_int128_add(a,b)      _cairo_uint128_add(a,b)
     233                 : #define                 _cairo_int128_sub(a,b)      _cairo_uint128_sub(a,b)
     234                 : #define                 _cairo_int128_mul(a,b)      _cairo_uint128_mul(a,b)
     235                 : cairo_int128_t I _cairo_int64x64_128_mul (cairo_int64_t a, cairo_int64_t b);
     236                 : #define                 _cairo_int64x32_128_mul(a, b) _cairo_int64x64_128_mul(a, _cairo_int32_to_int64(b))
     237                 : #define                 _cairo_int128_lsl(a,b)      _cairo_uint128_lsl(a,b)
     238                 : #define                 _cairo_int128_rsl(a,b)      _cairo_uint128_rsl(a,b)
     239                 : #define                 _cairo_int128_rsa(a,b)      _cairo_uint128_rsa(a,b)
     240                 : int             I       _cairo_int128_lt (cairo_int128_t a, cairo_int128_t b);
     241                 : int             I       _cairo_int128_cmp (cairo_int128_t a, cairo_int128_t b);
     242                 : #define                 _cairo_int128_is_zero(a)    _cairo_uint128_is_zero (a)
     243                 : #define                 _cairo_int128_eq(a,b)       _cairo_uint128_eq (a,b)
     244                 : #define                 _cairo_int128_negate(a)     _cairo_uint128_negate(a)
     245                 : #define                 _cairo_int128_negative(a)   (_cairo_uint128_negative(a))
     246                 : #define                 _cairo_int128_not(a)        _cairo_uint128_not(a)
     247                 : 
     248                 : #else   /* !HAVE_UINT128_T */
     249                 : 
     250                 : #define                 _cairo_uint32_to_uint128(i) ((uint128_t) (i))
     251                 : #define                 _cairo_uint64_to_uint128(i) ((uint128_t) (i))
     252                 : #define                 _cairo_uint128_to_uint64(i) ((uint64_t) (i))
     253                 : #define                 _cairo_uint128_to_uint32(i) ((uint32_t) (i))
     254                 : #define                 _cairo_uint128_add(a,b)     ((a) + (b))
     255                 : #define                 _cairo_uint128_sub(a,b)     ((a) - (b))
     256                 : #define                 _cairo_uint128_mul(a,b)     ((a) * (b))
     257                 : #define                 _cairo_uint64x64_128_mul(a,b)   ((uint128_t) (a) * (b))
     258                 : #define                 _cairo_uint128_lsl(a,b)     ((a) << (b))
     259                 : #define                 _cairo_uint128_rsl(a,b)     ((uint128_t) (a) >> (b))
     260                 : #define                 _cairo_uint128_rsa(a,b)     ((uint128_t) ((int128_t) (a) >> (b)))
     261                 : #define                 _cairo_uint128_lt(a,b)      ((a) < (b))
     262                 : #define                 _cairo_uint128_cmp(a,b)     ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
     263                 : #define                 _cairo_uint128_is_zero(a)   ((a) == 0)
     264                 : #define                 _cairo_uint128_eq(a,b)      ((a) == (b))
     265                 : #define                 _cairo_uint128_negate(a)    ((uint128_t) -((int128_t) (a)))
     266                 : #define                 _cairo_uint128_negative(a)  ((int128_t) (a) < 0)
     267                 : #define                 _cairo_uint128_not(a)       (~(a))
     268                 : 
     269                 : #define                 _cairo_uint128_to_int128(i) ((int128_t) (i))
     270                 : #define                 _cairo_int128_to_uint128(i) ((uint128_t) (i))
     271                 : 
     272                 : #define                 _cairo_int32_to_int128(i)   ((int128_t) (i))
     273                 : #define                 _cairo_int64_to_int128(i)   ((int128_t) (i))
     274                 : #define                 _cairo_int128_to_int64(i)   ((int64_t) (i))
     275                 : #define                 _cairo_int128_to_int32(i)   ((int32_t) (i))
     276                 : #define                 _cairo_int128_add(a,b)      ((a) + (b))
     277                 : #define                 _cairo_int128_sub(a,b)      ((a) - (b))
     278                 : #define                 _cairo_int128_mul(a,b)      ((a) * (b))
     279                 : #define                 _cairo_int64x64_128_mul(a,b) ((int128_t) (a) * (b))
     280                 : #define                 _cairo_int64x32_128_mul(a, b) _cairo_int64x64_128_mul(a, _cairo_int32_to_int64(b))
     281                 : #define                 _cairo_int128_lt(a,b)       ((a) < (b))
     282                 : #define                 _cairo_int128_cmp(a,b)      ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
     283                 : #define                 _cairo_int128_is_zero(a)    ((a) == 0)
     284                 : #define                 _cairo_int128_eq(a,b)       ((a) == (b))
     285                 : #define                 _cairo_int128_lsl(a,b)      ((a) << (b))
     286                 : #define                 _cairo_int128_rsl(a,b)      ((int128_t) ((uint128_t) (a) >> (b)))
     287                 : #define                 _cairo_int128_rsa(a,b)      ((int128_t) (a) >> (b))
     288                 : #define                 _cairo_int128_negate(a)     (-(a))
     289                 : #define                 _cairo_int128_negative(a)   ((a) < 0)
     290                 : #define                 _cairo_int128_not(a)        (~(a))
     291                 : 
     292                 : #endif  /* HAVE_UINT128_T */
     293                 : 
     294                 : cairo_uquorem128_t I
     295                 : _cairo_uint128_divrem (cairo_uint128_t num, cairo_uint128_t den);
     296                 : 
     297                 : cairo_quorem128_t I
     298                 : _cairo_int128_divrem (cairo_int128_t num, cairo_int128_t den);
     299                 : 
     300                 : cairo_uquorem64_t I
     301                 : _cairo_uint_96by64_32x64_divrem (cairo_uint128_t num,
     302                 :                                  cairo_uint64_t  den);
     303                 : 
     304                 : cairo_quorem64_t I
     305                 : _cairo_int_96by64_32x64_divrem (cairo_int128_t num,
     306                 :                                 cairo_int64_t  den);
     307                 : 
     308                 : #define                 _cairo_uint128_le(a,b)      (!_cairo_uint128_gt(a,b))
     309                 : #define                 _cairo_uint128_ne(a,b)      (!_cairo_uint128_eq(a,b))
     310                 : #define                 _cairo_uint128_ge(a,b)      (!_cairo_uint128_lt(a,b))
     311                 : #define                 _cairo_uint128_gt(a,b)      _cairo_uint128_lt(b,a)
     312                 : 
     313                 : #define                 _cairo_int128_le(a,b)       (!_cairo_int128_gt(a,b))
     314                 : #define                 _cairo_int128_ne(a,b)       (!_cairo_int128_eq(a,b))
     315                 : #define                 _cairo_int128_ge(a,b)       (!_cairo_int128_lt(a,b))
     316                 : #define                 _cairo_int128_gt(a,b)       _cairo_int128_lt(b,a)
     317                 : 
     318                 : #undef I
     319                 : 
     320                 : #endif /* CAIRO_WIDEINT_H */

Generated by: LCOV version 1.7