PR c++/86342 - -Wdeprecated-copy and system headers.

[official-gcc.git] / libgo / misc / cgo / gmp / gmp.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
An example of wrapping a C library in Go. This is the GNU
multiprecision library gmp's integer type mpz_t wrapped to look like
the Go package big's integer type Int.

This is a syntactically valid Go program—it can be parsed with the Go
parser and processed by godoc—but it is not compiled directly by gc.
Instead, a separate tool, cgo, processes it to produce three output
files.  The first two, 6g.go and 6c.c, are a Go source file for 6g and
a C source file for 6c; both compile as part of the named package
(gmp, in this example).  The third, gcc.c, is a C source file for gcc;
it compiles into a shared object (.so) that is dynamically linked into
any 6.out that imports the first two files.

The stanza

        // #include <gmp.h>
        import "C"

is a signal to cgo.  The doc comment on the import of "C" provides
additional context for the C file.  Here it is just a single #include
but it could contain arbitrary C definitions to be imported and used.

Cgo recognizes any use of a qualified identifier C.xxx and uses gcc to
find the definition of xxx.  If xxx is a type, cgo replaces C.xxx with
a Go translation.  C arithmetic types translate to precisely-sized Go
arithmetic types.  A C struct translates to a Go struct, field by
field; unrepresentable fields are replaced with opaque byte arrays.  A
C union translates into a struct containing the first union member and
perhaps additional padding.  C arrays become Go arrays.  C pointers
become Go pointers.  C function pointers become Go's uintptr.
C void pointers become Go's unsafe.Pointer.

For example, mpz_t is defined in <gmp.h> as:

        typedef unsigned long int mp_limb_t;

        typedef struct
        {
                int _mp_alloc;
                int _mp_size;
                mp_limb_t *_mp_d;
        } __mpz_struct;

        typedef __mpz_struct mpz_t[1];

Cgo generates:

        type _C_int int32
        type _C_mp_limb_t uint64
        type _C___mpz_struct struct {
                _mp_alloc _C_int;
                _mp_size _C_int;
                _mp_d *_C_mp_limb_t;
        }
        type _C_mpz_t [1]_C___mpz_struct

and then replaces each occurrence of a type C.xxx with _C_xxx.

If xxx is data, cgo arranges for C.xxx to refer to the C variable,
with the type translated as described above.  To do this, cgo must
introduce a Go variable that points at the C variable (the linker can
be told to initialize this pointer).  For example, if the gmp library
provided

        mpz_t zero;

then cgo would rewrite a reference to C.zero by introducing

        var _C_zero *C.mpz_t

and then replacing all instances of C.zero with (*_C_zero).

Cgo's most interesting translation is for functions.  If xxx is a C
function, then cgo rewrites C.xxx into a new function _C_xxx that
calls the C xxx in a standard pthread.  The new function translates
its arguments, calls xxx, and translates the return value.

Translation of parameters and the return value follows the type
translation above except that arrays passed as parameters translate
explicitly in Go to pointers to arrays, as they do (implicitly) in C.

Garbage collection is the big problem.  It is fine for the Go world to
have pointers into the C world and to free those pointers when they
are no longer needed.  To help, the Go code can define Go objects
holding the C pointers and use runtime.SetFinalizer on those Go objects.

It is much more difficult for the C world to have pointers into the Go
world, because the Go garbage collector is unaware of the memory
allocated by C.  The most important consideration is not to
constrain future implementations, so the rule is that Go code can
hand a Go pointer to C code but must separately arrange for
Go to hang on to a reference to the pointer until C is done with it.
*/
package gmp

/*
#cgo LDFLAGS: -lgmp
#include <gmp.h>
#include <stdlib.h>

// gmp 5.0.0+ changed the type of the 3rd argument to mp_bitcnt_t,
// so, to support older versions, we wrap these two functions.
void _mpz_mul_2exp(mpz_ptr a, mpz_ptr b, unsigned long n) {
        mpz_mul_2exp(a, b, n);
}
void _mpz_div_2exp(mpz_ptr a, mpz_ptr b, unsigned long n) {
        mpz_div_2exp(a, b, n);
}
*/
import "C"

import (
        "os"
        "unsafe"
)

/*
 * one of a kind
 */

// An Int represents a signed multi-precision integer.
// The zero value for an Int represents the value 0.
type Int struct {
        i    C.mpz_t
        init bool
}

// NewInt returns a new Int initialized to x.
func NewInt(x int64) *Int { return new(Int).SetInt64(x) }

// Int promises that the zero value is a 0, but in gmp
// the zero value is a crash.  To bridge the gap, the
// init bool says whether this is a valid gmp value.
// doinit initializes z.i if it needs it.  This is not inherent
// to FFI, just a mismatch between Go's convention of
// making zero values useful and gmp's decision not to.
func (z *Int) doinit() {
        if z.init {
                return
        }
        z.init = true
        C.mpz_init(&z.i[0])
}

// Bytes returns z's representation as a big-endian byte array.
func (z *Int) Bytes() []byte {
        b := make([]byte, (z.Len()+7)/8)
        n := C.size_t(len(b))
        C.mpz_export(unsafe.Pointer(&b[0]), &n, 1, 1, 1, 0, &z.i[0])
        return b[0:n]
}

// Len returns the length of z in bits.  0 is considered to have length 1.
func (z *Int) Len() int {
        z.doinit()
        return int(C.mpz_sizeinbase(&z.i[0], 2))
}

// Set sets z = x and returns z.
func (z *Int) Set(x *Int) *Int {
        z.doinit()
        C.mpz_set(&z.i[0], &x.i[0])
        return z
}

// SetBytes interprets b as the bytes of a big-endian integer
// and sets z to that value.
func (z *Int) SetBytes(b []byte) *Int {
        z.doinit()
        if len(b) == 0 {
                z.SetInt64(0)
        } else {
                C.mpz_import(&z.i[0], C.size_t(len(b)), 1, 1, 1, 0, unsafe.Pointer(&b[0]))
        }
        return z
}

// SetInt64 sets z = x and returns z.
func (z *Int) SetInt64(x int64) *Int {
        z.doinit()
        // TODO(rsc): more work on 32-bit platforms
        C.mpz_set_si(&z.i[0], C.long(x))
        return z
}

// SetString interprets s as a number in the given base
// and sets z to that value.  The base must be in the range [2,36].
// SetString returns an error if s cannot be parsed or the base is invalid.
func (z *Int) SetString(s string, base int) error {
        z.doinit()
        if base < 2 || base > 36 {
                return os.ErrInvalid
        }
        p := C.CString(s)
        defer C.free(unsafe.Pointer(p))
        if C.mpz_set_str(&z.i[0], p, C.int(base)) < 0 {
                return os.ErrInvalid
        }
        return nil
}

// String returns the decimal representation of z.
func (z *Int) String() string {
        if z == nil {
                return "nil"
        }
        z.doinit()
        p := C.mpz_get_str(nil, 10, &z.i[0])
        s := C.GoString(p)
        C.free(unsafe.Pointer(p))
        return s
}

func (z *Int) destroy() {
        if z.init {
                C.mpz_clear(&z.i[0])
        }
        z.init = false
}

/*
 * arithmetic
 */

// Add sets z = x + y and returns z.
func (z *Int) Add(x, y *Int) *Int {
        x.doinit()
        y.doinit()
        z.doinit()
        C.mpz_add(&z.i[0], &x.i[0], &y.i[0])
        return z
}

// Sub sets z = x - y and returns z.
func (z *Int) Sub(x, y *Int) *Int {
        x.doinit()
        y.doinit()
        z.doinit()
        C.mpz_sub(&z.i[0], &x.i[0], &y.i[0])
        return z
}

// Mul sets z = x * y and returns z.
func (z *Int) Mul(x, y *Int) *Int {
        x.doinit()
        y.doinit()
        z.doinit()
        C.mpz_mul(&z.i[0], &x.i[0], &y.i[0])
        return z
}

// Div sets z = x / y, rounding toward zero, and returns z.
func (z *Int) Div(x, y *Int) *Int {
        x.doinit()
        y.doinit()
        z.doinit()
        C.mpz_tdiv_q(&z.i[0], &x.i[0], &y.i[0])
        return z
}

// Mod sets z = x % y and returns z.
// Like the result of the Go % operator, z has the same sign as x.
func (z *Int) Mod(x, y *Int) *Int {
        x.doinit()
        y.doinit()
        z.doinit()
        C.mpz_tdiv_r(&z.i[0], &x.i[0], &y.i[0])
        return z
}

// Lsh sets z = x << s and returns z.
func (z *Int) Lsh(x *Int, s uint) *Int {
        x.doinit()
        z.doinit()
        C._mpz_mul_2exp(&z.i[0], &x.i[0], C.ulong(s))
        return z
}

// Rsh sets z = x >> s and returns z.
func (z *Int) Rsh(x *Int, s uint) *Int {
        x.doinit()
        z.doinit()
        C._mpz_div_2exp(&z.i[0], &x.i[0], C.ulong(s))
        return z
}

// Exp sets z = x^y % m and returns z.
// If m == nil, Exp sets z = x^y.
func (z *Int) Exp(x, y, m *Int) *Int {
        m.doinit()
        x.doinit()
        y.doinit()
        z.doinit()
        if m == nil {
                C.mpz_pow_ui(&z.i[0], &x.i[0], C.mpz_get_ui(&y.i[0]))
        } else {
                C.mpz_powm(&z.i[0], &x.i[0], &y.i[0], &m.i[0])
        }
        return z
}

func (z *Int) Int64() int64 {
        if !z.init {
                return 0
        }
        return int64(C.mpz_get_si(&z.i[0]))
}

// Neg sets z = -x and returns z.
func (z *Int) Neg(x *Int) *Int {
        x.doinit()
        z.doinit()
        C.mpz_neg(&z.i[0], &x.i[0])
        return z
}

// Abs sets z to the absolute value of x and returns z.
func (z *Int) Abs(x *Int) *Int {
        x.doinit()
        z.doinit()
        C.mpz_abs(&z.i[0], &x.i[0])
        return z
}

/*
 * functions without a clear receiver
 */

// CmpInt compares x and y. The result is
//
//   -1 if x <  y
//    0 if x == y
//   +1 if x >  y
//
func CmpInt(x, y *Int) int {
        x.doinit()
        y.doinit()
        switch cmp := C.mpz_cmp(&x.i[0], &y.i[0]); {
        case cmp < 0:
                return -1
        case cmp == 0:
                return 0
        }
        return +1
}

// DivModInt sets q = x / y and r = x % y.
func DivModInt(q, r, x, y *Int) {
        q.doinit()
        r.doinit()
        x.doinit()
        y.doinit()
        C.mpz_tdiv_qr(&q.i[0], &r.i[0], &x.i[0], &y.i[0])
}

// GcdInt sets d to the greatest common divisor of a and b,
// which must be positive numbers.
// If x and y are not nil, GcdInt sets x and y such that d = a*x + b*y.
// If either a or b is not positive, GcdInt sets d = x = y = 0.
func GcdInt(d, x, y, a, b *Int) {
        d.doinit()
        x.doinit()
        y.doinit()
        a.doinit()
        b.doinit()
        C.mpz_gcdext(&d.i[0], &x.i[0], &y.i[0], &a.i[0], &b.i[0])
}

// ProbablyPrime performs n Miller-Rabin tests to check whether z is prime.
// If it returns true, z is prime with probability 1 - 1/4^n.
// If it returns false, z is not prime.
func (z *Int) ProbablyPrime(n int) bool {
        z.doinit()
        return int(C.mpz_probab_prime_p(&z.i[0], C.int(n))) > 0
}