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