243 lines
6.2 KiB
C
243 lines
6.2 KiB
C
/*
|
|
* intdiv.c - Provide integer div/mod for MPFR.
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2017, 2018, 2021, 2022, the Free Software Foundation, Inc.
|
|
*
|
|
* This file is part of GAWK, the GNU implementation of the
|
|
* AWK Programming Language.
|
|
*
|
|
* GAWK is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GAWK is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <math.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "gawkapi.h"
|
|
|
|
#ifdef HAVE_MPFR
|
|
#include <gmp.h>
|
|
#include <mpfr.h>
|
|
#ifndef MPFR_RNDZ
|
|
/* for compatibility with MPFR 2.X */
|
|
#define MPFR_RNDZ GMP_RNDZ
|
|
#endif
|
|
#endif
|
|
|
|
#include "gettext.h"
|
|
#define _(msgid) gettext(msgid)
|
|
#define N_(msgid) msgid
|
|
|
|
static const gawk_api_t *api; /* for convenience macros to work */
|
|
static awk_ext_id_t ext_id;
|
|
static const char *ext_version = "intdiv extension: version 1.0";
|
|
static awk_bool_t (*init_func)(void) = NULL;
|
|
|
|
int plugin_is_GPL_compatible;
|
|
|
|
/* double_to_int --- get the integer part of a double */
|
|
|
|
static double
|
|
double_to_int(double d)
|
|
{
|
|
if (d >= 0)
|
|
d = floor(d);
|
|
else
|
|
d = ceil(d);
|
|
return d;
|
|
}
|
|
|
|
/* array_set_number --- set an array element to a numeric value */
|
|
|
|
static void
|
|
array_set_number(awk_array_t array, const char *sub, size_t sublen, double num)
|
|
{
|
|
awk_value_t index, tmp;
|
|
|
|
set_array_element(array, make_const_string(sub, sublen, & index), make_number(num, & tmp));
|
|
}
|
|
|
|
#ifdef HAVE_MPFR
|
|
|
|
/* mpz_conv --- convert an awk_value_t to an MPZ value */
|
|
|
|
static mpz_ptr
|
|
mpz_conv(const awk_value_t *arg, mpz_ptr tmp)
|
|
{
|
|
switch (arg->num_type) {
|
|
case AWK_NUMBER_TYPE_MPZ:
|
|
return arg->num_ptr;
|
|
case AWK_NUMBER_TYPE_MPFR:
|
|
if (! mpfr_number_p(arg->num_ptr))
|
|
return NULL;
|
|
mpz_init(tmp);
|
|
mpfr_get_z(tmp, arg->num_ptr, MPFR_RNDZ);
|
|
return tmp;
|
|
case AWK_NUMBER_TYPE_DOUBLE: /* can this happen? */
|
|
mpz_init(tmp);
|
|
mpz_set_d(tmp, double_to_int(arg->num_value));
|
|
return tmp;
|
|
default: /* should never happen */
|
|
fatal(ext_id, _("intdiv: invalid numeric type `%d'"), arg->num_type);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* array_set_mpz --- set an array element to an MPZ value */
|
|
|
|
static void
|
|
array_set_mpz(awk_array_t array, const char *sub, size_t sublen, mpz_ptr num)
|
|
{
|
|
awk_value_t index, tmp;
|
|
|
|
set_array_element(array, make_const_string(sub, sublen, & index), make_number_mpz(num, & tmp));
|
|
}
|
|
|
|
#endif
|
|
|
|
/* do_intdiv --- do integer division, return quotient and remainder in dest array */
|
|
|
|
/*
|
|
* We define the semantics as:
|
|
* numerator = int(numerator)
|
|
* denominator = int(denonmator)
|
|
* quotient = int(numerator / denomator)
|
|
* remainder = int(numerator % denomator)
|
|
*/
|
|
|
|
static awk_value_t *
|
|
do_intdiv(int nargs, awk_value_t *result, struct awk_ext_func *unused)
|
|
{
|
|
awk_value_t nv, dv, array_param;
|
|
awk_array_t array;
|
|
|
|
if (! get_argument(0, AWK_NUMBER, & nv)) {
|
|
warning(ext_id, _("intdiv: first argument must be numeric"));
|
|
return make_number(-1, result);
|
|
}
|
|
if (! get_argument(1, AWK_NUMBER, & dv)) {
|
|
warning(ext_id, _("intdiv: second argument must be numeric"));
|
|
return make_number(-1, result);
|
|
}
|
|
if (! get_argument(2, AWK_ARRAY, & array_param)) {
|
|
warning(ext_id, _("intdiv: third argument must be an array"));
|
|
return make_number(-1, result);
|
|
}
|
|
array = array_param.array_cookie;
|
|
clear_array(array);
|
|
|
|
#ifdef HAVE_MPFR
|
|
if (nv.num_type == AWK_NUMBER_TYPE_DOUBLE && dv.num_type == AWK_NUMBER_TYPE_DOUBLE)
|
|
#endif
|
|
{
|
|
/* regular precision */
|
|
double num, denom, quotient, remainder;
|
|
|
|
#ifndef HAVE_MPFR
|
|
if (nv.num_type != AWK_NUMBER_TYPE_DOUBLE || dv.num_type != AWK_NUMBER_TYPE_DOUBLE) {
|
|
static int warned = 0;
|
|
if (!warned) {
|
|
warning(ext_id, _("intdiv: MPFR arguments converted to IEEE because this extension was not compiled with MPFR support; loss of precision may occur"));
|
|
warned = 1;
|
|
}
|
|
}
|
|
#endif
|
|
num = double_to_int(nv.num_value);
|
|
denom = double_to_int(dv.num_value);
|
|
|
|
if (denom == 0.0) {
|
|
warning(ext_id, _("intdiv: division by zero attempted"));
|
|
return make_number(-1, result);
|
|
}
|
|
|
|
quotient = double_to_int(num / denom);
|
|
#ifdef HAVE_FMOD
|
|
remainder = fmod(num, denom);
|
|
#else /* ! HAVE_FMOD */
|
|
(void) modf(num / denom, & remainder);
|
|
remainder = num - remainder * denom;
|
|
#endif /* ! HAVE_FMOD */
|
|
remainder = double_to_int(remainder);
|
|
|
|
array_set_number(array, "quotient", 8, quotient);
|
|
array_set_number(array, "remainder", 9, remainder);
|
|
}
|
|
#ifdef HAVE_MPFR
|
|
else {
|
|
/* extended precision */
|
|
mpz_ptr numer, denom;
|
|
mpz_t numer_tmp, denom_tmp;
|
|
mpz_t quotient, remainder;
|
|
|
|
/* convert numerator and denominator to integer */
|
|
if (!(numer = mpz_conv(&nv, numer_tmp))) {
|
|
warning(ext_id, _("intdiv: numerator is not finite"));
|
|
return make_number(-1, result);
|
|
}
|
|
if (!(denom = mpz_conv(&dv, denom_tmp))) {
|
|
warning(ext_id, _("intdiv: denominator is not finite"));
|
|
if (numer == numer_tmp)
|
|
mpz_clear(numer);
|
|
return make_number(-1, result);
|
|
}
|
|
if (mpz_sgn(denom) == 0) {
|
|
warning(ext_id, _("intdiv: division by zero attempted"));
|
|
if (numer == numer_tmp)
|
|
mpz_clear(numer);
|
|
if (denom == denom_tmp)
|
|
mpz_clear(denom);
|
|
return make_number(-1, result);
|
|
}
|
|
|
|
mpz_init(quotient);
|
|
mpz_init(remainder);
|
|
|
|
/* do the division */
|
|
mpz_tdiv_qr(quotient, remainder, numer, denom);
|
|
|
|
array_set_mpz(array, "quotient", 8, quotient);
|
|
array_set_mpz(array, "remainder", 9, remainder);
|
|
|
|
/* release temporary variables */
|
|
if (numer == numer_tmp)
|
|
mpz_clear(numer);
|
|
if (denom == denom_tmp)
|
|
mpz_clear(denom);
|
|
}
|
|
#endif
|
|
|
|
return make_number(0, result);
|
|
}
|
|
|
|
static awk_ext_func_t func_table[] = {
|
|
{ "intdiv", do_intdiv, 3, 3, awk_false, NULL },
|
|
};
|
|
|
|
/* define the dl_load function using the boilerplate macro */
|
|
|
|
dl_load_func(func_table, intdiv, "")
|