modules/mpeval.c

   1 /* GNU m4 -- A simple macro processor
   2    Copyright (C) 2000, 2001, 2006, 2007, 2008 Free Software
   3    Foundation, Inc.
   4
   5    This file is part of GNU M4.
   6
   7    GNU M4 is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    GNU M4 is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <config.h>
  22
  23 /* Build using only the exported interfaces, unless NDEBUG is set, in
  24    which case use private symbols to speed things up as much as possible.  */
  25 #ifndef NDEBUG
  26 #  include <m4/m4module.h>
  27 #else
  28 #  include "m4private.h"
  29 #endif
  30
  31 #if HAVE_GMP_H
  32 #  include <gmp.h>
  33 #endif
  34
  35 #include "quotearg.h"
  36
  37 /* Rename exported symbols for dlpreload()ing.  */
  38 #define m4_builtin_table        mpeval_LTX_m4_builtin_table
  39 #define m4_macro_table          mpeval_LTX_m4_macro_table
  40
  41
  42 /* Maintain each of the builtins implemented in this modules along
  43    with their details in a single table for easy maintenance.
  44
  45            function     macros  blind   side    minargs maxargs */
  46 #define builtin_functions                                       \
  47   BUILTIN (mpeval,      false,  true,   true,   1,      3  )    \
  48
  49
  50
  51 #define numb_set(ans, i) mpq_set (ans, i)
  52 #define numb_set_si(ans, i) mpq_set_si (*(ans), (long) i, (unsigned long) 1)
  53
  54 #define numb_init(x) mpq_init (x)
  55 #define numb_fini(x) mpq_clear (x)
  56
  57 #define numb_zerop(x)     (mpq_cmp (x, numb_ZERO) == 0)
  58 #define numb_positivep(x) (mpq_cmp (x, numb_ZERO) >  0)
  59 #define numb_negativep(x) (mpq_cmp (x, numb_ZERO) <  0)
  60
  61 #define numb_eq(x, y) numb_set (x, mpq_cmp (x, y) == 0 ? numb_ONE : numb_ZERO)
  62 #define numb_ne(x, y) numb_set (x, mpq_cmp (x, y) != 0 ? numb_ONE : numb_ZERO)
  63 #define numb_lt(x, y) numb_set (x, mpq_cmp (x, y) <  0 ? numb_ONE : numb_ZERO)
  64 #define numb_le(x, y) numb_set (x, mpq_cmp (x, y) <= 0 ? numb_ONE : numb_ZERO)
  65 #define numb_gt(x, y) numb_set (x, mpq_cmp (x, y) >  0 ? numb_ONE : numb_ZERO)
  66 #define numb_ge(x, y) numb_set (x, mpq_cmp (x, y) >= 0 ? numb_ONE : numb_ZERO)
  67
  68 #define numb_lnot(x)    numb_set (x, numb_zerop (x) ? numb_ONE : numb_ZERO)
  69 #define numb_lior(x, y) numb_set (x, numb_zerop (x) ? y : x)
  70 #define numb_land(x, y) numb_set (x, numb_zerop (x) ? numb_ZERO : y)
  71
  72 #define reduce1(f1, x)                                                  \
  73   do                                                                    \
  74     {                                                                   \
  75       number T;                                                         \
  76       mpq_init (T);                                                     \
  77       f1 (T, x);                                                        \
  78       mpq_set (x, T);                                                   \
  79       mpq_clear (T);                                                    \
  80     }                                                                   \
  81   while (0)
  82 #define reduce2(f2,x,y)                                                 \
  83   do                                                                    \
  84     {                                                                   \
  85       number T;                                                         \
  86       mpq_init (T);                                                     \
  87       f2 (T, (x), (y));                                                 \
  88       mpq_set ((x), T);                                                 \
  89       mpq_clear (T);                                                    \
  90     }                                                                   \
  91   while (0)
  92
  93 #define numb_plus(x, y)  reduce2 (mpq_add, x, y)
  94 #define numb_minus(x, y) reduce2 (mpq_sub, x, y)
  95 #define numb_negate(x)   reduce1 (mpq_neg, x)
  96
  97 #define numb_times(x, y) reduce2 (mpq_mul, x, y)
  98 #define numb_ratio(x, y) reduce2 (mpq_div, x, y)
  99 #define numb_invert(x)   reduce1 (mpq_inv, x)
 100
 101 #define numb_incr(n) numb_plus  (n, numb_ONE)
 102 #define numb_decr(n) numb_minus (n, numb_ONE)
 103
 104 /* Generate prototypes for each builtin handler function. */
 105 #define BUILTIN(handler, macros, blind, side, min, max)  M4BUILTIN (handler)
 106   builtin_functions
 107 #undef BUILTIN
 108
 109
 110 /* Generate a table for mapping m4 symbol names to handler functions. */
 111 const m4_builtin m4_builtin_table[] =
 112 {
 113 #define BUILTIN(handler, macros, blind, side, min, max)                 \
 114   M4BUILTIN_ENTRY (handler, #handler, macros, blind, side, min, max)
 115
 116   builtin_functions
 117 #undef BUILTIN
 118
 119   { NULL, NULL, 0, 0, 0 },
 120 };
 121
 122
 123 /* A table for mapping m4 symbol names to simple expansion text. */
 124 const m4_macro m4_macro_table[] =
 125 {
 126   /* name               text    min     max */
 127   { "__mpeval__",       "",     0,      0 },
 128   { NULL,               NULL,   0,      0 },
 129 };
 130
 131
 132 /* GMP defines mpq_t as a 1-element array of struct.  Therefore, `mpq_t'
 133    is not compatible with `const mpq_t'.  */
 134 typedef mpq_t number;
 135
 136 static void numb_initialise (void);
 137 static void numb_obstack (m4_obstack *obs, const number value,
 138                           const int radix, int min);
 139 static void mpq2mpz (m4 *context, mpz_t z, const number q, const char *noisily);
 140 static void mpz2mpq (number q, const mpz_t z);
 141 static void numb_divide (number *x, number *y);
 142 static void numb_modulo (m4 *context, number *x, number *y);
 143 static void numb_and (m4 *context, number *x, number *y);
 144 static void numb_ior (m4 *context, number *x, number *y);
 145 static void numb_eor (m4 *context, number *x, number *y);
 146 static void numb_not (m4 *context, number *x);
 147 static void numb_lshift (m4 *context, number *x, number *y);
 148 static void numb_rshift (m4 *context, number *x, number *y);
 149 #define numb_urshift(c, x, y) numb_rshift (c, x, y)
 150 \f
 151
 152 static number numb_ZERO;
 153 static number numb_ONE;
 154
 155 static int numb_initialised = 0;
 156
 157 static void
 158 numb_initialise (void)
 159 {
 160   if (numb_initialised)
 161     return;
 162
 163   numb_init (numb_ZERO);
 164   numb_set_si (&numb_ZERO, 0);
 165
 166   numb_init (numb_ONE);
 167   numb_set_si (&numb_ONE, 1);
 168
 169   numb_initialised = 1;
 170 }
 171
 172 static void
 173 numb_obstack (m4_obstack *obs, const number value, const int radix,
 174               int min)
 175 {
 176   const char *s;
 177   size_t len;
 178
 179   mpz_t i;
 180   mpz_init (i);
 181
 182   mpq_get_num (i, value);
 183   s = mpz_get_str (NULL, radix, i);
 184
 185   if (*s == '-')
 186     {
 187       obstack_1grow (obs, '-');
 188       s++;
 189     }
 190   len = strlen (s);
 191   for (min -= len; --min >= 0;)
 192     obstack_1grow (obs, '0');
 193
 194   obstack_grow (obs, s, len);
 195
 196   mpq_get_den (i, value);
 197   if (mpz_cmp_si (i, (long) 1) != 0)
 198     {
 199       obstack_1grow (obs, '\\');
 200       s = mpz_get_str ((char *) 0, radix, i);
 201       obstack_grow (obs, s, strlen (s));
 202     }
 203
 204   mpz_clear (i);
 205 }
 206
 207 #define NOISY ""
 208 #define QUIET (char *)0
 209
 210 static void
 211 mpq2mpz (m4 *context, mpz_t z, const number q, const char *noisily)
 212 {
 213   if (noisily && mpz_cmp_si (mpq_denref (q), (long) 1) != 0)
 214     m4_warn (context, 0, NULL, _("loss of precision in eval: %s"), noisily);
 215
 216   mpz_div (z, mpq_numref (q), mpq_denref (q));
 217 }
 218
 219 static void
 220 mpz2mpq (number q, const mpz_t z)
 221 {
 222   mpq_set_si (q, (long) 0, (unsigned long) 1);
 223   mpq_set_num (q, z);
 224 }
 225
 226 static void
 227 numb_divide (number * x, number * y)
 228 {
 229   mpq_t qres;
 230   mpz_t zres;
 231
 232   mpq_init (qres);
 233   mpq_div (qres, *x, *y);
 234
 235   mpz_init (zres);
 236   mpz_div (zres, mpq_numref (qres), mpq_denref (qres));
 237   mpq_clear (qres);
 238
 239   mpz2mpq (*x, zres);
 240   mpz_clear (zres);
 241 }
 242
 243 static void
 244 numb_modulo (m4 *context, number * x, number * y)
 245 {
 246   mpz_t xx, yy, res;
 247
 248   /* x should be integral */
 249   /* y should be integral */
 250
 251   mpz_init (xx);
 252   mpq2mpz (context, xx, *x, NOISY);
 253
 254   mpz_init (yy);
 255   mpq2mpz (context, yy, *y, NOISY);
 256
 257   mpz_init (res);
 258   mpz_mod (res, xx, yy);
 259
 260   mpz_clear (xx);
 261   mpz_clear (yy);
 262
 263   mpz2mpq (*x, res);
 264   mpz_clear (res);
 265 }
 266
 267 static void
 268 numb_and (m4 *context, number * x, number * y)
 269 {
 270   mpz_t xx, yy, res;
 271
 272   /* x should be integral */
 273   /* y should be integral */
 274
 275   mpz_init (xx);
 276   mpq2mpz (context, xx, *x, NOISY);
 277
 278   mpz_init (yy);
 279   mpq2mpz (context, yy, *y, NOISY);
 280
 281   mpz_init (res);
 282   mpz_and (res, xx, yy);
 283
 284   mpz_clear (xx);
 285   mpz_clear (yy);
 286
 287   mpz2mpq (*x, res);
 288   mpz_clear (res);
 289 }
 290
 291 static void
 292 numb_ior (m4 *context, number * x, number * y)
 293 {
 294   mpz_t xx, yy, res;
 295
 296   /* x should be integral */
 297   /* y should be integral */
 298
 299   mpz_init (xx);
 300   mpq2mpz (context, xx, *x, NOISY);
 301
 302   mpz_init (yy);
 303   mpq2mpz (context, yy, *y, NOISY);
 304
 305   mpz_init (res);
 306   mpz_ior (res, xx, yy);
 307
 308   mpz_clear (xx);
 309   mpz_clear (yy);
 310
 311   mpz2mpq (*x, res);
 312   mpz_clear (res);
 313 }
 314
 315 static void
 316 numb_eor (m4 *context, number * x, number * y)
 317 {
 318   mpz_t xx, yy, res;
 319
 320   /* x should be integral */
 321   /* y should be integral */
 322
 323   mpz_init (xx);
 324   mpq2mpz (context, xx, *x, NOISY);
 325
 326   mpz_init (yy);
 327   mpq2mpz (context, yy, *y, NOISY);
 328
 329   mpz_init (res);
 330
 331 #if 0
 332   mpz_xor (res, xx, yy);
 333 #else /* 0 */
 334   /* a^b = (a|b) & !(a&b) */
 335   {
 336     mpz_t and_ab, ior_ab, nand_ab;
 337
 338     mpz_init (ior_ab);
 339     mpz_ior (ior_ab, xx, yy);
 340
 341     mpz_init (and_ab);
 342     mpz_and (and_ab, xx, yy);
 343
 344     mpz_init (nand_ab);
 345     mpz_com (nand_ab, and_ab);
 346
 347     mpz_and (res, ior_ab, nand_ab);
 348
 349     mpz_clear (and_ab);
 350     mpz_clear (ior_ab);
 351     mpz_clear (nand_ab);
 352   }
 353 #endif /* 0 */
 354
 355   mpz_clear (xx);
 356   mpz_clear (yy);
 357
 358   mpz2mpq (*x, res);
 359   mpz_clear (res);
 360 }
 361
 362 static void
 363 numb_not (m4 *context, number * x)
 364 {
 365   mpz_t xx, res;
 366
 367   /* x should be integral */
 368
 369   mpz_init (xx);
 370   mpq2mpz (context, xx, *x, NOISY);
 371
 372   mpz_init (res);
 373   mpz_com (res, xx);
 374
 375   mpz_clear (xx);
 376
 377   mpz2mpq (*x, res);
 378   mpz_clear (res);
 379 }
 380
 381 static void
 382 numb_lshift (m4 *context, number * x, number * y)
 383 {
 384   mpz_t xx, yy, res;
 385
 386   /* x should be integral */
 387   /* y should be integral */
 388
 389   mpz_init (xx);
 390   mpq2mpz (context, xx, *x, NOISY);
 391
 392   mpz_init (yy);
 393   mpq2mpz (context, yy, *y, NOISY);
 394
 395   mpz_init (res);
 396   {
 397     /* bug: need to determine if y is too big or negative. */
 398     long int exp = mpz_get_si (yy);
 399     if (exp >= 0)
 400       {
 401         mpz_mul_2exp (res, xx, (unsigned) exp);
 402       }
 403     else
 404       {
 405         mpz_div_2exp (res, xx, (unsigned) -exp);
 406       }
 407   }
 408
 409   mpz_clear (xx);
 410   mpz_clear (yy);
 411
 412   mpz2mpq (*x, res);
 413   mpz_clear (res);
 414 }
 415
 416 static void
 417 numb_rshift (m4 *context, number * x, number * y)
 418 {
 419   mpz_t xx, yy, res;
 420
 421   /* x should be integral */
 422   /* y should be integral */
 423
 424   mpz_init (xx);
 425   mpq2mpz (context, xx, *x, NOISY);
 426
 427   mpz_init (yy);
 428   mpq2mpz (context, yy, *y, NOISY);
 429
 430   mpz_init (res);
 431   {
 432     /* FIXME: bug - need to determine if y is too big or negative */
 433     long int exp = mpz_get_si (yy);
 434     if (exp >= 0)
 435       {
 436         mpz_div_2exp (res, xx, (unsigned) exp);
 437       }
 438     else
 439       {
 440         mpz_mul_2exp (res, xx, (unsigned) -exp);
 441       }
 442   }
 443
 444   mpz_clear (xx);
 445   mpz_clear (yy);
 446
 447   mpz2mpq (*x, res);
 448   mpz_clear (res);
 449 }
 450
 451 #define m4_evaluate     builtin_mpeval
 452 #include "evalparse.c"