stdlib/gmp.h

   1 /* gmp.h -- Definitions for GNU multiple precision functions.
   2
   3 Copyright (C) 1991, 1993, 1994 Free Software Foundation, Inc.
   4
   5 This file is part of the GNU MP Library.
   6
   7 The GNU MP Library is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU Library General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or (at your
  10 option) any later version.
  11
  12 The GNU MP Library is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
  15 License for more details.
  16
  17 You should have received a copy of the GNU Library General Public License
  18 along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
  19 the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  20
  21 #ifndef __GMP_H__
  22
  23 #ifndef __GNU_MP__
  24 #define __need_size_t
  25 #include <stddef.h>
  26
  27 #if defined (__STDC__)
  28 #define __gmp_const const
  29 #else
  30 #define __gmp_const
  31 #endif
  32
  33 #if defined (__GNUC__)
  34 #define __gmp_inline inline
  35 #else
  36 #define __gmp_inline
  37 #endif
  38
  39 #ifdef _SHORT_LIMB
  40 typedef unsigned int            mp_limb;
  41 typedef int                     mp_limb_signed;
  42 #else
  43 #if _LONG_LONG_LIMB
  44 typedef unsigned long long int  mp_limb;
  45 typedef long long int           mp_limb_signed;
  46 #else
  47 typedef unsigned long int       mp_limb;
  48 typedef long int                mp_limb_signed;
  49 #endif
  50 #endif
  51
  52 typedef mp_limb *               mp_ptr;
  53 typedef __gmp_const mp_limb *   mp_srcptr;
  54 typedef int                     mp_size_t;
  55 typedef long int                mp_exp_t;
  56
  57 #ifndef __MP_SMALL__
  58 typedef struct
  59 {
  60   mp_size_t alloc;              /* Number of *limbs* allocated and pointed
  61                                    to by the D field.  */
  62   mp_size_t size;               /* abs(SIZE) is the number of limbs
  63                                    the last field points to.  If SIZE
  64                                    is negative this is a negative
  65                                    number.  */
  66   mp_limb *d;                   /* Pointer to the limbs.  */
  67 } __mpz_struct;
  68 #else
  69 typedef struct
  70 {
  71   short int alloc;              /* Number of *limbs* allocated and pointed
  72                                    to by the D field.  */
  73   short int size;               /* abs(SIZE) is the number of limbs
  74                                    the last field points to.  If SIZE
  75                                    is negative this is a negative
  76                                    number.  */
  77   mp_limb *d;                   /* Pointer to the limbs.  */
  78 } __mpz_struct;
  79 #endif
  80 #endif /* __GNU_MP__ */
  81
  82 /* User-visible types.  */
  83 typedef __mpz_struct MP_INT;
  84 typedef __mpz_struct mpz_t[1];
  85
  86 /* Structure for rational numbers.  Zero is represented as 0/any, i.e.
  87    the denominator is ignored.  Negative numbers have the sign in
  88    the numerator.  */
  89 typedef struct
  90 {
  91   __mpz_struct num;
  92   __mpz_struct den;
  93 #if 0
  94   long int num_alloc;           /* Number of limbs allocated
  95                                    for the numerator.  */
  96   long int num_size;            /* The absolute value of this field is the
  97                                    length of the numerator; the sign is the
  98                                    sign of the entire rational number.  */
  99   mp_ptr num;                   /* Pointer to the numerator limbs.  */
 100   long int den_alloc;           /* Number of limbs allocated
 101                                    for the denominator.  */
 102   long int den_size;            /* Length of the denominator.  (This field
 103                                    should always be positive.) */
 104   mp_ptr den;                   /* Pointer to the denominator limbs.  */
 105 #endif
 106 } __mpq_struct;
 107
 108 typedef __mpq_struct MP_RAT;
 109 typedef __mpq_struct mpq_t[1];
 110
 111 typedef struct
 112 {
 113   mp_size_t alloc;              /* Number of *limbs* allocated and pointed
 114                                    to by the D field.  */
 115   mp_size_t prec;               /* Max precision, in number of `mp_limb's.
 116                                    Set by mpf_init and modified by
 117                                    mpf_set_prec.  */
 118   mp_size_t size;               /* abs(SIZE) is the number of limbs
 119                                    the last field points to.  If SIZE
 120                                    is negative this is a negative
 121                                    number.  */
 122   mp_exp_t exp;                 /* Exponent, in the base of `mp_limb'.  */
 123   mp_limb *d;                   /* Pointer to the limbs.  */
 124 } __mpf_struct;
 125
 126 /* typedef __mpf_struct MP_FLOAT; */
 127 typedef __mpf_struct mpf_t[1];
 128
 129 /* Types for function declarations in gmp files.  */
 130 /* ??? Should not pollute user name space ??? */
 131 typedef __gmp_const __mpz_struct *mpz_srcptr;
 132 typedef __mpz_struct *mpz_ptr;
 133 typedef __gmp_const __mpf_struct *mpf_srcptr;
 134 typedef __mpf_struct *mpf_ptr;
 135 typedef __gmp_const __mpq_struct *mpq_srcptr;
 136 typedef __mpq_struct *mpq_ptr;
 137
 138 #if defined (__STDC__)
 139 #define _PROTO(x) x
 140 #else
 141 #define _PROTO(x) ()
 142 #endif
 143
 144 #if defined (FILE) || defined (_STDIO_H_) || defined (__STDIO_H__) || defined (H_STDIO)
 145 #define _GMP_H_HAVE_FILE 1
 146 #endif
 147
 148 void mp_set_memory_functions _PROTO((void *(*) (size_t),
 149                                      void *(*) (void *, size_t, size_t),
 150                                      void (*) (void *, size_t)));
 151
 152 /**************** Integer (i.e. Z) routines.  ****************/
 153
 154 void *_mpz_realloc _PROTO ((mpz_ptr, mp_size_t));
 155
 156 void mpz_abs _PROTO ((mpz_ptr, mpz_srcptr));
 157 void mpz_add _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 158 void mpz_add_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 159 void mpz_and _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 160 void mpz_clear _PROTO ((mpz_ptr));
 161 void mpz_clrbit _PROTO ((mpz_ptr, unsigned long int));
 162 int mpz_cmp _PROTO ((mpz_srcptr, mpz_srcptr));
 163 int mpz_cmp_si _PROTO ((mpz_srcptr, signed long int));
 164 int mpz_cmp_ui _PROTO ((mpz_srcptr, unsigned long int));
 165 void mpz_com _PROTO ((mpz_ptr, mpz_srcptr));
 166 void mpz_div_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 167 void mpz_fac_ui _PROTO ((mpz_ptr, unsigned long int));
 168 void mpz_gcd _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 169 unsigned long int mpz_gcd_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 170 void mpz_gcdext _PROTO ((mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 171 /* signed */ long int mpz_get_si _PROTO ((mpz_srcptr));
 172 char *mpz_get_str _PROTO ((char *, int, mpz_srcptr));
 173 unsigned long int mpz_get_ui _PROTO ((mpz_srcptr));
 174 mp_limb mpz_getlimbn _PROTO ((mpz_srcptr, mp_size_t));
 175 mp_size_t mpz_hamdist _PROTO ((mpz_srcptr, mpz_srcptr));
 176 void mpz_init _PROTO ((mpz_ptr));
 177 #ifdef _GMP_H_HAVE_FILE
 178 void mpz_inp_raw _PROTO ((mpz_ptr, FILE *));
 179 int mpz_inp_str _PROTO ((mpz_ptr, FILE *, int));
 180 #endif
 181 void mpz_ior _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 182 void mpz_init_set _PROTO ((mpz_ptr, mpz_srcptr));
 183 void mpz_init_set_si _PROTO ((mpz_ptr, signed long int));
 184 int mpz_init_set_str _PROTO ((mpz_ptr, const char *, int));
 185 void mpz_init_set_ui _PROTO ((mpz_ptr, unsigned long int));
 186 void mpz_lcm _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 187 void mpz_mod_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 188 void mpz_mul _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 189 void mpz_mul_2exp _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 190 void mpz_mul_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 191 void mpz_neg _PROTO ((mpz_ptr, mpz_srcptr));
 192 #ifdef _GMP_H_HAVE_FILE
 193 void mpz_out_raw _PROTO ((FILE *, mpz_srcptr));
 194 void mpz_out_str _PROTO ((FILE *, int, mpz_srcptr));
 195 #endif
 196 int mpz_perfect_square_p _PROTO ((mpz_srcptr));
 197 mp_size_t mpz_popcount _PROTO ((mpz_srcptr));
 198 void mpz_pow_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 199 void mpz_powm _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr));
 200 void mpz_powm_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr));
 201 int mpz_probab_prime_p _PROTO ((mpz_srcptr, int));
 202 void mpz_random _PROTO ((mpz_ptr, mp_size_t));
 203 void mpz_random2 _PROTO ((mpz_ptr, mp_size_t));
 204 void mpz_set _PROTO ((mpz_ptr, mpz_srcptr));
 205 void mpz_set_si _PROTO ((mpz_ptr, signed long int));
 206 int mpz_set_str _PROTO ((mpz_ptr, const char *, int));
 207 void mpz_set_ui _PROTO ((mpz_ptr, unsigned long int));
 208 size_t mpz_size _PROTO ((mpz_srcptr));
 209 size_t mpz_sizeinbase _PROTO ((mpz_srcptr, int));
 210 void mpz_sqrt _PROTO ((mpz_ptr, mpz_srcptr));
 211 void mpz_sqrtrem _PROTO ((mpz_ptr, mpz_ptr, mpz_srcptr));
 212 void mpz_sub _PROTO ((mpz_ptr, mpz_srcptr, mpz_srcptr));
 213 void mpz_sub_ui _PROTO ((mpz_ptr, mpz_srcptr, unsigned long int));
 214 void mpz_ui_pow_ui _PROTO ((mpz_ptr, unsigned long int, unsigned long int));
 215
 216 void mpz_fdiv_q _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
 217 unsigned long int mpz_fdiv_q_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
 218 void mpz_fdiv_qr _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 219 unsigned long int mpz_fdiv_qr_ui _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
 220 void mpz_fdiv_r _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
 221 unsigned long int mpz_fdiv_r_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
 222 unsigned long int mpz_fdiv_ui _PROTO((mpz_srcptr, unsigned long int));
 223 void mpz_tdiv_q _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
 224 void mpz_tdiv_q_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
 225 void mpz_tdiv_qr _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr));
 226 void mpz_tdiv_qr_ui _PROTO((mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int));
 227 void mpz_tdiv_r _PROTO((mpz_ptr, mpz_srcptr, mpz_srcptr));
 228 void mpz_tdiv_r_ui _PROTO((mpz_ptr, mpz_srcptr, unsigned long int));
 229
 230 void mpz_array_init (mpz_ptr, size_t, mp_size_t);
 231
 232 /**************** Rational (i.e. Q) routines.  ****************/
 233
 234 void mpq_init _PROTO ((mpq_ptr));
 235 void mpq_clear _PROTO ((mpq_ptr));
 236 void mpq_set _PROTO ((mpq_ptr, mpq_srcptr));
 237 void mpq_set_ui _PROTO ((mpq_ptr, unsigned long int, unsigned long int));
 238 void mpq_set_si _PROTO ((mpq_ptr, signed long int, unsigned long int));
 239 void mpq_add _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 240 void mpq_sub _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 241 void mpq_mul _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 242 void mpq_div _PROTO ((mpq_ptr, mpq_srcptr, mpq_srcptr));
 243 void mpq_neg _PROTO ((mpq_ptr, mpq_srcptr));
 244 int mpq_cmp _PROTO ((mpq_srcptr, mpq_srcptr));
 245 void mpq_inv _PROTO ((mpq_ptr, mpq_srcptr));
 246 void mpq_set_num _PROTO ((mpq_ptr, mpz_srcptr));
 247 void mpq_set_den _PROTO ((mpq_ptr, mpz_srcptr));
 248 void mpq_get_num _PROTO ((mpz_ptr, mpq_srcptr));
 249 void mpq_get_den _PROTO ((mpz_ptr, mpq_srcptr));
 250
 251 /**************** Float (i.e. F) routines.  ****************/
 252
 253 void mpf_abs _PROTO ((mpf_ptr, mpf_srcptr));
 254 void mpf_add _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 255 void mpf_add_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 256 void mpf_clear _PROTO ((mpf_ptr));
 257 int mpf_cmp _PROTO ((mpf_srcptr, mpf_srcptr));
 258 int mpf_cmp_si _PROTO ((mpf_srcptr, long int));
 259 int mpf_cmp_ui _PROTO ((mpf_srcptr, unsigned long int));
 260 void mpf_div _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 261 void mpf_div_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 262 void mpf_div_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 263 void mpf_dump _PROTO ((mpf_srcptr));
 264 char *mpf_get_str _PROTO ((char *, mp_exp_t *, int, size_t, mpf_srcptr));
 265 void mpf_init _PROTO ((mpf_ptr));
 266 void mpf_init2 _PROTO ((mpf_ptr, mp_size_t));
 267 #ifdef _GMP_H_HAVE_FILE
 268 void mpf_inp_str _PROTO ((mpf_ptr, FILE *, int));
 269 #endif
 270 void mpf_init_set _PROTO ((mpf_ptr, mpf_srcptr));
 271 void mpf_init_set_d _PROTO ((mpf_ptr, double));
 272 void mpf_init_set_si _PROTO ((mpf_ptr, long int));
 273 int mpf_init_set_str _PROTO ((mpf_ptr, char *, int));
 274 void mpf_init_set_ui _PROTO ((mpf_ptr, unsigned long int));
 275 void mpf_mul _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 276 void mpf_mul_2exp _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 277 void mpf_mul_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 278 void mpf_neg _PROTO ((mpf_ptr, mpf_srcptr));
 279 #ifdef _GMP_H_HAVE_FILE
 280 void mpf_out_str _PROTO ((mpf_ptr, int, size_t, FILE *));
 281 #endif
 282 void mpf_set _PROTO ((mpf_ptr, mpf_srcptr));
 283 void mpf_set_d _PROTO ((mpf_ptr, double));
 284 mp_size_t mpf_set_default_prec _PROTO ((mp_size_t));
 285 void mpf_set_si _PROTO ((mpf_ptr, long int));
 286 int mpf_set_str _PROTO ((mpf_ptr, const char *, int));
 287 void mpf_set_ui _PROTO ((mpf_ptr, unsigned long int));
 288 size_t mpf_size _PROTO ((mpf_srcptr));
 289 void mpf_sqrt _PROTO ((mpf_ptr, mpf_srcptr));
 290 void mpf_sqrt_ui _PROTO ((mpf_ptr, unsigned long int));
 291 void mpf_sub _PROTO ((mpf_ptr, mpf_srcptr, mpf_srcptr));
 292 void mpf_sub_ui _PROTO ((mpf_ptr, mpf_srcptr, unsigned long int));
 293 void mpf_ui_div _PROTO ((mpf_ptr, unsigned long int, mpf_srcptr));
 294
 295 /************ Low level positive-integer (i.e. N) routines.  ************/
 296
 297 /* This is ugly, but we need to make usr calls reach the prefixed function.  */
 298 #define mpn_add_n       __mpn_add_n
 299 #define mpn_sub_n       __mpn_sub_n
 300 #define mpn_mul_1       __mpn_mul_1
 301 #define mpn_addmul_1    __mpn_addmul_1
 302 #define mpn_submul_1    __mpn_submul_1
 303 #define mpn_lshift      __mpn_lshift
 304 #define mpn_rshift      __mpn_rshift
 305 #define mpn_sub         __mpn_sub
 306 #define mpn_add         __mpn_add
 307 #define mpn_normal_size __mpn_normal_size
 308 #define mpn_cmp         __mpn_cmp
 309 #define mpn_add_1       __mpn_add_1
 310 #define mpn_sub_1       __mpn_sub_1
 311 #define mpn_mul_n       __mpn_mul_n
 312 #define mpn_mul         __mpn_mul
 313 #define mpn_divmod      __mpn_divmod
 314 #define mpn_divmod_1    __mpn_divmod_1
 315 #define mpn_mod_1       __mpn_mod_1
 316 #define mpn_sqrt        __mpn_sqrt
 317 #define mpn_next_bit_set __mpn_next_bit_set
 318 #define mpn_popcount    __mpn_popcount
 319 #define mpn_hamdist     __mpn_hamdist
 320 #define mpn_random2     __mpn_random2
 321 #define mpn_set_str     __mpn_set_str
 322 #define mpn_get_str     __mpn_get_str
 323 #define mpn_gcd_1       __mpn_gcd_1
 324
 325 mp_limb __mpn_add_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 326 mp_limb __mpn_sub_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 327 mp_limb __mpn_mul _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t));
 328 void __mpn_mul_n _PROTO ((mp_ptr, mp_srcptr, mp_srcptr, mp_size_t));
 329 mp_limb __mpn_mul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
 330 mp_limb __mpn_addmul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
 331 mp_limb __mpn_submul_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
 332 mp_limb __mpn_divmod _PROTO ((mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t));
 333 mp_limb __mpn_divmod_1 _PROTO ((mp_ptr, mp_srcptr, mp_size_t, mp_limb));
 334 mp_limb __mpn_mod_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
 335 mp_limb __mpn_lshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
 336 mp_limb __mpn_rshift _PROTO ((mp_ptr, mp_srcptr, mp_size_t, unsigned int));
 337 mp_size_t __mpn_sqrt _PROTO ((mp_ptr, mp_ptr, mp_srcptr, mp_size_t));
 338 int __mpn_cmp _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
 339 mp_size_t __mpn_next_bit_set _PROTO ((mp_srcptr, mp_size_t));
 340 mp_size_t __mpn_popcount _PROTO ((mp_srcptr, mp_size_t));
 341 mp_size_t __mpn_hamdist _PROTO ((mp_srcptr, mp_srcptr, mp_size_t));
 342 void __mpn_random2 _PROTO ((mp_ptr, mp_size_t));
 343 mp_size_t __mpn_set_str _PROTO ((mp_ptr, const unsigned char *, size_t, int));
 344 size_t __mpn_get_str _PROTO ((unsigned char *, int, mp_ptr, mp_size_t));
 345 mp_limb __mpn_gcd_1 _PROTO ((mp_srcptr, mp_size_t, mp_limb));
 346
 347
 348 static __gmp_inline mp_limb
 349 #if defined (__STDC__)
 350 __mpn_add_1 (register mp_ptr res_ptr,
 351              register mp_srcptr s1_ptr,
 352              register mp_size_t s1_size,
 353              register mp_limb s2_limb)
 354 #else
 355 __mpn_add_1 (res_ptr, s1_ptr, s1_size, s2_limb)
 356      register mp_ptr res_ptr;
 357      register mp_srcptr s1_ptr;
 358      register mp_size_t s1_size;
 359      register mp_limb s2_limb;
 360 #endif
 361 {
 362   register mp_limb x;
 363
 364   x = *s1_ptr++;
 365   s2_limb = x + s2_limb;
 366   *res_ptr++ = s2_limb;
 367   if (s2_limb < x)
 368     {
 369       while (--s1_size != 0)
 370         {
 371           x = *s1_ptr++ + 1;
 372           *res_ptr++ = x;
 373           if (x != 0)
 374             goto fin;
 375         }
 376
 377       return 1;
 378     }
 379
 380  fin:
 381   if (res_ptr != s1_ptr)
 382     {
 383       mp_size_t i;
 384       for (i = 0; i < s1_size - 1; i++)
 385         res_ptr[i] = s1_ptr[i];
 386     }
 387   return 0;
 388 }
 389
 390 static __gmp_inline mp_limb
 391 #if defined (__STDC__)
 392 __mpn_add (register mp_ptr res_ptr,
 393            register mp_srcptr s1_ptr,
 394            register mp_size_t s1_size,
 395            register mp_srcptr s2_ptr,
 396            register mp_size_t s2_size)
 397 #else
 398 __mpn_add (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
 399      register mp_ptr res_ptr;
 400      register mp_srcptr s1_ptr;
 401      register mp_size_t s1_size;
 402      register mp_srcptr s2_ptr;
 403      register mp_size_t s2_size;
 404 #endif
 405 {
 406   mp_limb cy_limb = 0;
 407
 408   if (s2_size != 0)
 409     cy_limb = __mpn_add_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 410
 411   if (s1_size - s2_size != 0)
 412     cy_limb =  __mpn_add_1 (res_ptr + s2_size,
 413                             s1_ptr + s2_size,
 414                             s1_size - s2_size,
 415                             cy_limb);
 416   return cy_limb;
 417 }
 418
 419 static __gmp_inline mp_limb
 420 #if defined (__STDC__)
 421 __mpn_sub_1 (register mp_ptr res_ptr,
 422              register mp_srcptr s1_ptr,
 423              register mp_size_t s1_size,
 424              register mp_limb s2_limb)
 425 #else
 426 __mpn_sub_1 (res_ptr, s1_ptr, s1_size, s2_limb)
 427      register mp_ptr res_ptr;
 428      register mp_srcptr s1_ptr;
 429      register mp_size_t s1_size;
 430      register mp_limb s2_limb;
 431 #endif
 432 {
 433   register mp_limb x;
 434
 435   x = *s1_ptr++;
 436   s2_limb = x - s2_limb;
 437   *res_ptr++ = s2_limb;
 438   if (s2_limb > x)
 439     {
 440       while (--s1_size != 0)
 441         {
 442           x = *s1_ptr++;
 443           *res_ptr++ = x - 1;
 444           if (x != 0)
 445             goto fin;
 446         }
 447
 448       return 1;
 449     }
 450
 451  fin:
 452   if (res_ptr != s1_ptr)
 453     {
 454       mp_size_t i;
 455       for (i = 0; i < s1_size - 1; i++)
 456         res_ptr[i] = s1_ptr[i];
 457     }
 458   return 0;
 459 }
 460
 461 static __gmp_inline mp_limb
 462 #if defined (__STDC__)
 463 __mpn_sub (register mp_ptr res_ptr,
 464            register mp_srcptr s1_ptr,
 465            register mp_size_t s1_size,
 466            register mp_srcptr s2_ptr,
 467            register mp_size_t s2_size)
 468 #else
 469 __mpn_sub (res_ptr, s1_ptr, s1_size, s2_ptr, s2_size)
 470      register mp_ptr res_ptr;
 471      register mp_srcptr s1_ptr;
 472      register mp_size_t s1_size;
 473      register mp_srcptr s2_ptr;
 474      register mp_size_t s2_size;
 475 #endif
 476 {
 477   mp_limb cy_limb = 0;
 478
 479   if (s2_size != 0)
 480     cy_limb = __mpn_sub_n (res_ptr, s1_ptr, s2_ptr, s2_size);
 481
 482   if (s1_size - s2_size != 0)
 483     cy_limb =  __mpn_sub_1 (res_ptr + s2_size,
 484                             s1_ptr + s2_size,
 485                             s1_size - s2_size,
 486                             cy_limb);
 487   return cy_limb;
 488 }
 489
 490 static __gmp_inline mp_size_t
 491 #if defined (__STDC__)
 492 __mpn_normal_size (mp_srcptr ptr, mp_size_t size)
 493 #else
 494 __mpn_normal_size (ptr, size)
 495      mp_srcptr ptr;
 496      mp_size_t size;
 497 #endif
 498 {
 499   while (size)
 500     {
 501       size--;
 502       if (ptr[size] != 0)
 503         return size + 1;
 504     }
 505   return 0;
 506 }
 507
 508 /* Compatibility with GMP 1.  */
 509
 510 #define mpz_mdiv        mpz_fdiv_q
 511 #define mpz_mdivmod     mpz_fdiv_qr
 512 #define mpz_mmod        mpz_fdiv_r
 513 #define mpz_mdiv_ui     mpz_fdiv_q_ui
 514 #define mpz_mdivmod_ui(q,r,n,d) \
 515   ((r == 0) ? mpz_fdiv_q_ui (q,n,d) : mpz_fdiv_qr_ui (q,r,n,d))
 516 #define mpz_mmod_ui(r,n,d) \
 517   ((r == 0) ? mpz_fdiv_ui (n,d) : mpz_fdiv_r_ui (r,n,d))
 518 /* ??? Before release...
 519 #define mpz_div_2exp    mpz_fdiv_q_2exp
 520 #define mpz_mod_2exp    mpz_fdiv_r_2exp
 521 */
 522
 523 /* Useful synonyms, but not quite compatible with GMP 1.  */
 524 #define mpz_div         mpz_fdiv_q
 525 #define mpz_divmod      mpz_fdiv_qr
 526 #define mpz_div_ui      mpz_fdiv_q_ui
 527 #define mpz_divmod_ui   mpz_fdiv_qr_ui
 528 #define mpz_mod_ui      mpz_fdiv_r_ui
 529
 530
 531 #define __GNU_MP__ 2
 532 #define __GNU_MP_VERSION 2
 533 #define __GNU_MP_VERSION_MINOR -900 /* ??? */
 534 #define __GMP_H__
 535 #endif /* __GMP_H__ */