Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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_double_to_uint64 (double i);
  58. double         I        _cairo_uint64_to_double (cairo_uint64_t i);
  59. cairo_int64_t  I        _cairo_double_to_int64 (double i);
  60. double         I        _cairo_int64_to_double (cairo_uint64_t i);
  61.  
  62. cairo_uint64_t I        _cairo_uint32_to_uint64 (uint32_t i);
  63. #define                 _cairo_uint64_to_uint32(a)  ((a).lo)
  64. cairo_uint64_t I        _cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
  65. cairo_uint64_t I        _cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
  66. cairo_uint64_t I        _cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
  67. cairo_uint64_t I        _cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
  68. cairo_uint64_t I        _cairo_uint64_lsl (cairo_uint64_t a, int shift);
  69. cairo_uint64_t I        _cairo_uint64_rsl (cairo_uint64_t a, int shift);
  70. cairo_uint64_t I        _cairo_uint64_rsa (cairo_uint64_t a, int shift);
  71. int            I        _cairo_uint64_lt (cairo_uint64_t a, cairo_uint64_t b);
  72. int            I        _cairo_uint64_cmp (cairo_uint64_t a, cairo_uint64_t b);
  73. int            I        _cairo_uint64_eq (cairo_uint64_t a, cairo_uint64_t b);
  74. cairo_uint64_t I        _cairo_uint64_negate (cairo_uint64_t a);
  75. #define                 _cairo_uint64_is_zero(a) ((a).hi == 0 && (a).lo == 0)
  76. #define                 _cairo_uint64_negative(a)   (((int32_t) ((a).hi)) < 0)
  77. cairo_uint64_t I        _cairo_uint64_not (cairo_uint64_t a);
  78.  
  79. #define                 _cairo_uint64_to_int64(i)   (i)
  80. #define                 _cairo_int64_to_uint64(i)   (i)
  81.  
  82. cairo_int64_t  I        _cairo_int32_to_int64(int32_t i);
  83. #define                 _cairo_int64_to_int32(a)    ((int32_t) _cairo_uint64_to_uint32(a))
  84. #define                 _cairo_int64_add(a,b)       _cairo_uint64_add (a,b)
  85. #define                 _cairo_int64_sub(a,b)       _cairo_uint64_sub (a,b)
  86. #define                 _cairo_int64_mul(a,b)       _cairo_uint64_mul (a,b)
  87. cairo_int64_t  I        _cairo_int32x32_64_mul (int32_t a, int32_t b);
  88. int            I        _cairo_int64_lt (cairo_int64_t a, cairo_int64_t b);
  89. int            I        _cairo_int64_cmp (cairo_int64_t a, cairo_int64_t b);
  90. #define                 _cairo_int64_is_zero(a)     _cairo_uint64_is_zero (a)
  91. #define                 _cairo_int64_eq(a,b)        _cairo_uint64_eq (a,b)
  92. #define                 _cairo_int64_lsl(a,b)       _cairo_uint64_lsl (a,b)
  93. #define                 _cairo_int64_rsl(a,b)       _cairo_uint64_rsl (a,b)
  94. #define                 _cairo_int64_rsa(a,b)       _cairo_uint64_rsa (a,b)
  95. #define                 _cairo_int64_negate(a)      _cairo_uint64_negate(a)
  96. #define                 _cairo_int64_negative(a)    (((int32_t) ((a).hi)) < 0)
  97. #define                 _cairo_int64_not(a)         _cairo_uint64_not(a)
  98.  
  99. #else
  100.  
  101. static inline cairo_uquorem64_t
  102. _cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den)
  103. {
  104.     cairo_uquorem64_t   qr;
  105.  
  106.     qr.quo = num / den;
  107.     qr.rem = num % den;
  108.     return qr;
  109. }
  110.  
  111. /*
  112.  * These need to be functions or gcc will complain when used on the
  113.  * result of a function:
  114.  *
  115.  * warning: cast from function call of type ‘#cairo_uint64_t’ to
  116.  * non-matching type ‘double’
  117.  */
  118. static cairo_always_inline cairo_const cairo_uint64_t _cairo_double_to_uint64 (double i) { return i; }
  119. static cairo_always_inline cairo_const double _cairo_uint64_to_double (cairo_uint64_t i) { return i; }
  120.  
  121. static cairo_always_inline cairo_int64_t I _cairo_double_to_int64 (double i) { return i; }
  122. static cairo_always_inline double I _cairo_int64_to_double (cairo_int64_t i) { return i; }
  123.  
  124. #define                 _cairo_uint32_to_uint64(i)  ((uint64_t) (i))
  125. #define                 _cairo_uint64_to_uint32(i)  ((uint32_t) (i))
  126. #define                 _cairo_uint64_add(a,b)      ((a) + (b))
  127. #define                 _cairo_uint64_sub(a,b)      ((a) - (b))
  128. #define                 _cairo_uint64_mul(a,b)      ((a) * (b))
  129. #define                 _cairo_uint32x32_64_mul(a,b)    ((uint64_t) (a) * (b))
  130. #define                 _cairo_uint64_lsl(a,b)      ((a) << (b))
  131. #define                 _cairo_uint64_rsl(a,b)      ((uint64_t) (a) >> (b))
  132. #define                 _cairo_uint64_rsa(a,b)      ((uint64_t) ((int64_t) (a) >> (b)))
  133. #define                 _cairo_uint64_lt(a,b)       ((a) < (b))
  134. #define                 _cairo_uint64_cmp(a,b)       ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
  135. #define                 _cairo_uint64_is_zero(a)    ((a) == 0)
  136. #define                 _cairo_uint64_eq(a,b)       ((a) == (b))
  137. #define                 _cairo_uint64_negate(a)     ((uint64_t) -((int64_t) (a)))
  138. #define                 _cairo_uint64_negative(a)   ((int64_t) (a) < 0)
  139. #define                 _cairo_uint64_not(a)        (~(a))
  140.  
  141. #define                 _cairo_uint64_to_int64(i)   ((int64_t) (i))
  142. #define                 _cairo_int64_to_uint64(i)   ((uint64_t) (i))
  143.  
  144. #define                 _cairo_int32_to_int64(i)    ((int64_t) (i))
  145. #define                 _cairo_int64_to_int32(i)    ((int32_t) (i))
  146. #define                 _cairo_int64_add(a,b)       ((a) + (b))
  147. #define                 _cairo_int64_sub(a,b)       ((a) - (b))
  148. #define                 _cairo_int64_mul(a,b)       ((a) * (b))
  149. #define                 _cairo_int32x32_64_mul(a,b) ((int64_t) (a) * (b))
  150. #define                 _cairo_int64_lt(a,b)        ((a) < (b))
  151. #define                 _cairo_int64_cmp(a,b)       ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
  152. #define                 _cairo_int64_is_zero(a)     ((a) == 0)
  153. #define                 _cairo_int64_eq(a,b)        ((a) == (b))
  154. #define                 _cairo_int64_lsl(a,b)       ((a) << (b))
  155. #define                 _cairo_int64_rsl(a,b)       ((int64_t) ((uint64_t) (a) >> (b)))
  156. #define                 _cairo_int64_rsa(a,b)       ((int64_t) (a) >> (b))
  157. #define                 _cairo_int64_negate(a)      (-(a))
  158. #define                 _cairo_int64_negative(a)    ((a) < 0)
  159. #define                 _cairo_int64_not(a)         (~(a))
  160.  
  161. #endif
  162.  
  163. /*
  164.  * 64-bit comparisons derived from lt or eq
  165.  */
  166. #define                 _cairo_uint64_le(a,b)       (!_cairo_uint64_gt(a,b))
  167. #define                 _cairo_uint64_ne(a,b)       (!_cairo_uint64_eq(a,b))
  168. #define                 _cairo_uint64_ge(a,b)       (!_cairo_uint64_lt(a,b))
  169. #define                 _cairo_uint64_gt(a,b)       _cairo_uint64_lt(b,a)
  170.  
  171. #define                 _cairo_int64_le(a,b)        (!_cairo_int64_gt(a,b))
  172. #define                 _cairo_int64_ne(a,b)        (!_cairo_int64_eq(a,b))
  173. #define                 _cairo_int64_ge(a,b)        (!_cairo_int64_lt(a,b))
  174. #define                 _cairo_int64_gt(a,b)        _cairo_int64_lt(b,a)
  175.  
  176. /*
  177.  * As the C implementation always computes both, create
  178.  * a function which returns both for the 'native' type as well
  179.  */
  180.  
  181. static inline cairo_quorem64_t
  182. _cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den)
  183. {
  184.     int                 num_neg = _cairo_int64_negative (num);
  185.     int                 den_neg = _cairo_int64_negative (den);
  186.     cairo_uquorem64_t   uqr;
  187.     cairo_quorem64_t    qr;
  188.  
  189.     if (num_neg)
  190.         num = _cairo_int64_negate (num);
  191.     if (den_neg)
  192.         den = _cairo_int64_negate (den);
  193.     uqr = _cairo_uint64_divrem (num, den);
  194.     if (num_neg)
  195.         qr.rem = _cairo_int64_negate (uqr.rem);
  196.     else
  197.         qr.rem = uqr.rem;
  198.     if (num_neg != den_neg)
  199.         qr.quo = (cairo_int64_t) _cairo_int64_negate (uqr.quo);
  200.     else
  201.         qr.quo = (cairo_int64_t) uqr.quo;
  202.     return qr;
  203. }
  204.  
  205. static inline int32_t
  206. _cairo_int64_32_div (cairo_int64_t num, int32_t den)
  207. {
  208. #if !HAVE_UINT64_T
  209.     return _cairo_int64_to_int32
  210.         (_cairo_int64_divrem (num, _cairo_int32_to_int64 (den)).quo);
  211. #else
  212.     return num / den;
  213. #endif
  214. }
  215.  
  216. /*
  217.  * 128-bit datatypes.  Again, provide two implementations in
  218.  * case the machine has a native 128-bit datatype.  GCC supports int128_t
  219.  * on ia64
  220.  */
  221.  
  222. #if !HAVE_UINT128_T
  223.  
  224. cairo_uint128_t I       _cairo_uint32_to_uint128 (uint32_t i);
  225. cairo_uint128_t I       _cairo_uint64_to_uint128 (cairo_uint64_t i);
  226. #define                 _cairo_uint128_to_uint64(a)     ((a).lo)
  227. #define                 _cairo_uint128_to_uint32(a)     _cairo_uint64_to_uint32(_cairo_uint128_to_uint64(a))
  228. cairo_uint128_t I       _cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
  229. cairo_uint128_t I       _cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
  230. cairo_uint128_t I       _cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
  231. cairo_uint128_t I       _cairo_uint64x64_128_mul (cairo_uint64_t a, cairo_uint64_t b);
  232. cairo_uint128_t I       _cairo_uint128_lsl (cairo_uint128_t a, int shift);
  233. cairo_uint128_t I       _cairo_uint128_rsl (cairo_uint128_t a, int shift);
  234. cairo_uint128_t I       _cairo_uint128_rsa (cairo_uint128_t a, int shift);
  235. int             I       _cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
  236. int             I       _cairo_uint128_cmp (cairo_uint128_t a, cairo_uint128_t b);
  237. int             I       _cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
  238. #define                 _cairo_uint128_is_zero(a) (_cairo_uint64_is_zero ((a).hi) && _cairo_uint64_is_zero ((a).lo))
  239. cairo_uint128_t I       _cairo_uint128_negate (cairo_uint128_t a);
  240. #define                 _cairo_uint128_negative(a)  (_cairo_uint64_negative(a.hi))
  241. cairo_uint128_t I       _cairo_uint128_not (cairo_uint128_t a);
  242.  
  243. #define                 _cairo_uint128_to_int128(i)     (i)
  244. #define                 _cairo_int128_to_uint128(i)     (i)
  245.  
  246. cairo_int128_t  I       _cairo_int32_to_int128 (int32_t i);
  247. cairo_int128_t  I       _cairo_int64_to_int128 (cairo_int64_t i);
  248. #define                 _cairo_int128_to_int64(a)   ((cairo_int64_t) (a).lo)
  249. #define                 _cairo_int128_to_int32(a)   _cairo_int64_to_int32(_cairo_int128_to_int64(a))
  250. #define                 _cairo_int128_add(a,b)      _cairo_uint128_add(a,b)
  251. #define                 _cairo_int128_sub(a,b)      _cairo_uint128_sub(a,b)
  252. #define                 _cairo_int128_mul(a,b)      _cairo_uint128_mul(a,b)
  253. cairo_int128_t I _cairo_int64x64_128_mul (cairo_int64_t a, cairo_int64_t b);
  254. #define                 _cairo_int64x32_128_mul(a, b) _cairo_int64x64_128_mul(a, _cairo_int32_to_int64(b))
  255. #define                 _cairo_int128_lsl(a,b)      _cairo_uint128_lsl(a,b)
  256. #define                 _cairo_int128_rsl(a,b)      _cairo_uint128_rsl(a,b)
  257. #define                 _cairo_int128_rsa(a,b)      _cairo_uint128_rsa(a,b)
  258. int             I       _cairo_int128_lt (cairo_int128_t a, cairo_int128_t b);
  259. int             I       _cairo_int128_cmp (cairo_int128_t a, cairo_int128_t b);
  260. #define                 _cairo_int128_is_zero(a)    _cairo_uint128_is_zero (a)
  261. #define                 _cairo_int128_eq(a,b)       _cairo_uint128_eq (a,b)
  262. #define                 _cairo_int128_negate(a)     _cairo_uint128_negate(a)
  263. #define                 _cairo_int128_negative(a)   (_cairo_uint128_negative(a))
  264. #define                 _cairo_int128_not(a)        _cairo_uint128_not(a)
  265.  
  266. #else   /* !HAVE_UINT128_T */
  267.  
  268. #define                 _cairo_uint32_to_uint128(i) ((uint128_t) (i))
  269. #define                 _cairo_uint64_to_uint128(i) ((uint128_t) (i))
  270. #define                 _cairo_uint128_to_uint64(i) ((uint64_t) (i))
  271. #define                 _cairo_uint128_to_uint32(i) ((uint32_t) (i))
  272. #define                 _cairo_uint128_add(a,b)     ((a) + (b))
  273. #define                 _cairo_uint128_sub(a,b)     ((a) - (b))
  274. #define                 _cairo_uint128_mul(a,b)     ((a) * (b))
  275. #define                 _cairo_uint64x64_128_mul(a,b)   ((uint128_t) (a) * (b))
  276. #define                 _cairo_uint128_lsl(a,b)     ((a) << (b))
  277. #define                 _cairo_uint128_rsl(a,b)     ((uint128_t) (a) >> (b))
  278. #define                 _cairo_uint128_rsa(a,b)     ((uint128_t) ((int128_t) (a) >> (b)))
  279. #define                 _cairo_uint128_lt(a,b)      ((a) < (b))
  280. #define                 _cairo_uint128_cmp(a,b)     ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
  281. #define                 _cairo_uint128_is_zero(a)   ((a) == 0)
  282. #define                 _cairo_uint128_eq(a,b)      ((a) == (b))
  283. #define                 _cairo_uint128_negate(a)    ((uint128_t) -((int128_t) (a)))
  284. #define                 _cairo_uint128_negative(a)  ((int128_t) (a) < 0)
  285. #define                 _cairo_uint128_not(a)       (~(a))
  286.  
  287. #define                 _cairo_uint128_to_int128(i) ((int128_t) (i))
  288. #define                 _cairo_int128_to_uint128(i) ((uint128_t) (i))
  289.  
  290. #define                 _cairo_int32_to_int128(i)   ((int128_t) (i))
  291. #define                 _cairo_int64_to_int128(i)   ((int128_t) (i))
  292. #define                 _cairo_int128_to_int64(i)   ((int64_t) (i))
  293. #define                 _cairo_int128_to_int32(i)   ((int32_t) (i))
  294. #define                 _cairo_int128_add(a,b)      ((a) + (b))
  295. #define                 _cairo_int128_sub(a,b)      ((a) - (b))
  296. #define                 _cairo_int128_mul(a,b)      ((a) * (b))
  297. #define                 _cairo_int64x64_128_mul(a,b) ((int128_t) (a) * (b))
  298. #define                 _cairo_int64x32_128_mul(a, b) _cairo_int64x64_128_mul(a, _cairo_int32_to_int64(b))
  299. #define                 _cairo_int128_lt(a,b)       ((a) < (b))
  300. #define                 _cairo_int128_cmp(a,b)      ((a) == (b) ? 0 : (a) < (b) ? -1 : 1)
  301. #define                 _cairo_int128_is_zero(a)    ((a) == 0)
  302. #define                 _cairo_int128_eq(a,b)       ((a) == (b))
  303. #define                 _cairo_int128_lsl(a,b)      ((a) << (b))
  304. #define                 _cairo_int128_rsl(a,b)      ((int128_t) ((uint128_t) (a) >> (b)))
  305. #define                 _cairo_int128_rsa(a,b)      ((int128_t) (a) >> (b))
  306. #define                 _cairo_int128_negate(a)     (-(a))
  307. #define                 _cairo_int128_negative(a)   ((a) < 0)
  308. #define                 _cairo_int128_not(a)        (~(a))
  309.  
  310. #endif  /* HAVE_UINT128_T */
  311.  
  312. cairo_uquorem128_t I
  313. _cairo_uint128_divrem (cairo_uint128_t num, cairo_uint128_t den);
  314.  
  315. cairo_quorem128_t I
  316. _cairo_int128_divrem (cairo_int128_t num, cairo_int128_t den);
  317.  
  318. cairo_uquorem64_t I
  319. _cairo_uint_96by64_32x64_divrem (cairo_uint128_t num,
  320.                                  cairo_uint64_t  den);
  321.  
  322. cairo_quorem64_t I
  323. _cairo_int_96by64_32x64_divrem (cairo_int128_t num,
  324.                                 cairo_int64_t  den);
  325.  
  326. #define                 _cairo_uint128_le(a,b)      (!_cairo_uint128_gt(a,b))
  327. #define                 _cairo_uint128_ne(a,b)      (!_cairo_uint128_eq(a,b))
  328. #define                 _cairo_uint128_ge(a,b)      (!_cairo_uint128_lt(a,b))
  329. #define                 _cairo_uint128_gt(a,b)      _cairo_uint128_lt(b,a)
  330.  
  331. #define                 _cairo_int128_le(a,b)       (!_cairo_int128_gt(a,b))
  332. #define                 _cairo_int128_ne(a,b)       (!_cairo_int128_eq(a,b))
  333. #define                 _cairo_int128_ge(a,b)       (!_cairo_int128_lt(a,b))
  334. #define                 _cairo_int128_gt(a,b)       _cairo_int128_lt(b,a)
  335.  
  336. #undef I
  337.  
  338. #endif /* CAIRO_WIDEINT_H */
  339.