diff --git a/doc.go b/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..ef6fe62a8262f08587dbd928757518e83c167d55
--- /dev/null
+++ b/doc.go
@@ -0,0 +1 @@
+package pbc
\ No newline at end of file
diff --git a/element.go b/element.go
index b00ea72d5f0d589b941c389897056dabac05e4a5..a2a84f36c5a7e98d37b6e395ad3f9687929848d1 100644
--- a/element.go
+++ b/element.go
@@ -6,14 +6,11 @@ package pbc
import "C"
import (
- "errors"
"fmt"
"math/big"
"runtime"
)
-var ErrUnknownField = errors.New("unchecked element initialized in unknown field")
-
type Element interface {
NewFieldElement() Element
diff --git a/element_checked.go b/element_checked.go
index cb8f223cab2bd57a909a572d4904962bf1e73f94..e35ba7e89664340576e9117bd403bf7529d5e8e8 100644
--- a/element_checked.go
+++ b/element_checked.go
@@ -5,18 +5,7 @@ package pbc
*/
import "C"
-import (
- "errors"
- "math/big"
-)
-
-var (
- ErrIllegalOp = errors.New("operation is illegal for elements of this type")
- ErrUncheckedOp = errors.New("unchecked element passed to checked operation")
- ErrIncompatible = errors.New("elements are from incompatible fields or pairings")
- ErrOutOfRange = errors.New("index out of range")
- ErrInternal = errors.New("a severe internal error has lead to possible memory corruption")
-)
+import "math/big"
func (el *checkedElement) impl() *elementImpl { return &el.unchecked }
diff --git a/element_fmt.go b/element_fmt.go
index 8587e2e30416320b357010027891cc6880ebfba4..3ed783065dce6d1f411e8696246cae92700e0937 100644
--- a/element_fmt.go
+++ b/element_fmt.go
@@ -15,17 +15,11 @@ import "C"
import (
"bytes"
- "errors"
"fmt"
"io"
"unsafe"
)
-var (
- ErrBadInput = errors.New("invalid element format during scan")
- ErrBadVerb = errors.New("invalid verb specified for scan")
-)
-
func (el *elementImpl) errorFormat(f fmt.State, c rune, err string) {
fmt.Fprintf(f, "%%!%c(%s pbc.Element)", c, err)
}
diff --git a/element_unchecked.go b/element_unchecked.go
index 3c8c88c44c385bc36b69bce5a05b402fddb08197..b887b6e9f98bd9cadefeaf35ccba2e1fe1671e95 100644
--- a/element_unchecked.go
+++ b/element_unchecked.go
@@ -6,13 +6,10 @@ package pbc
import "C"
import (
- "errors"
"math/big"
"unsafe"
)
-var ErrBadPairList = errors.New("pairing product list is in an invalid format")
-
func (el *elementImpl) impl() *elementImpl { return el }
func (el *elementImpl) NewFieldElement() Element {
diff --git a/errors.go b/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..bc5006fdc8789cb32dd04dd0527d5fa23ac19864
--- /dev/null
+++ b/errors.go
@@ -0,0 +1,16 @@
+package pbc
+
+import "errors"
+
+var (
+ ErrInvalidParamString = errors.New("invalid pairing parameters")
+ ErrUnknownField = errors.New("unchecked element initialized in unknown field")
+ ErrIllegalOp = errors.New("operation is illegal for elements of this type")
+ ErrUncheckedOp = errors.New("unchecked element passed to checked operation")
+ ErrIncompatible = errors.New("elements are from incompatible fields or pairings")
+ ErrBadPairList = errors.New("pairing product list is in an invalid format")
+ ErrBadInput = errors.New("invalid element format during scan")
+ ErrBadVerb = errors.New("invalid verb specified for scan")
+ ErrOutOfRange = errors.New("index out of range")
+ ErrInternal = errors.New("a severe internal error has lead to possible memory corruption")
+)
diff --git a/generation.go b/generation.go
index a818935c6516f7f9debd9a6f19b62c87996fc784..b3b33a6cf5b600d1c4057692061504917c66c71d 100644
--- a/generation.go
+++ b/generation.go
@@ -22,36 +22,36 @@ import (
func GenerateA(rbits uint32, qbits uint32) Params {
params := makeParams()
- C.pbc_param_init_a_gen(params, C.int(rbits), C.int(qbits))
+ C.pbc_param_init_a_gen(params.data, C.int(rbits), C.int(qbits))
return params
}
func GenerateA1(n *big.Int) Params {
params := makeParams()
- C.pbc_param_init_a1_gen(params, &big2mpz(n)[0])
+ C.pbc_param_init_a1_gen(params.data, &big2mpz(n)[0])
return params
}
func GenerateD(d uint32, bitlimit uint32) Params {
params := makeParams()
- C.pbc_cm_search_d((*[0]byte)(C.acceptPairingD), unsafe.Pointer(params), C.uint(d), C.uint(bitlimit))
+ C.pbc_cm_search_d((*[0]byte)(C.acceptPairingD), unsafe.Pointer(params.data), C.uint(d), C.uint(bitlimit))
return params
}
func GenerateE(rbits uint32, qbits uint32) Params {
params := makeParams()
- C.pbc_param_init_e_gen(params, C.int(rbits), C.int(qbits))
+ C.pbc_param_init_e_gen(params.data, C.int(rbits), C.int(qbits))
return params
}
func GenerateF(bits uint32) Params {
params := makeParams()
- C.pbc_param_init_f_gen(params, C.int(bits))
+ C.pbc_param_init_f_gen(params.data, C.int(bits))
return params
}
func GenerateG(d uint32, bitlimit uint32) Params {
params := makeParams()
- C.pbc_cm_search_d((*[0]byte)(C.acceptPairingG), unsafe.Pointer(params), C.uint(d), C.uint(bitlimit))
+ C.pbc_cm_search_d((*[0]byte)(C.acceptPairingG), unsafe.Pointer(params.data), C.uint(d), C.uint(bitlimit))
return params
}
diff --git a/pairing.go b/pairing.go
index 00455e654c70ee1edbf21b9ec37894be23fbb1a8..0687a1ca305968f5460828e54dc2e2f6b49fc037 100644
--- a/pairing.go
+++ b/pairing.go
@@ -59,7 +59,7 @@ func NewPairingFromString(params string) (Pairing, error) {
func NewPairingFromParams(params Params) Pairing {
pairing := makePairing()
- C.pairing_init_pbc_param(pairing.data, params.(*C.struct_pbc_param_s))
+ C.pairing_init_pbc_param(pairing.data, params.(*paramsImpl).data)
return pairing
}
diff --git a/params.go b/params.go
index 6f6b6e59a99b9224105cb4345d162bd81f8991a7..5813f81e154a404c3a182178f7860e0885a00ed2 100644
--- a/params.go
+++ b/params.go
@@ -14,44 +14,45 @@ int param_out_str_wrapper(char** bufp, size_t* sizep, pbc_param_t p) {
import "C"
import (
- "errors"
"io"
"runtime"
"unsafe"
)
-var ErrInvalidParamString = errors.New("invalid pairing parameters")
-
type Params interface {
NewPairing() Pairing
WriteTo(w io.Writer) (n int64, err error)
String() string
}
+type paramsImpl struct {
+ data *C.struct_pbc_param_s
+}
+
func NewParamsFromString(s string) (Params, error) {
cstr := C.CString(s)
defer C.free(unsafe.Pointer(cstr))
params := makeParams()
- if ok := C.pbc_param_init_set_str(params, cstr); ok != 0 {
+ if ok := C.pbc_param_init_set_str(params.data, cstr); ok != 0 {
return nil, ErrInvalidParamString
}
return params, nil
}
-func (params *C.struct_pbc_param_s) NewPairing() Pairing {
+func (params *paramsImpl) NewPairing() Pairing {
return NewPairingFromParams(params)
}
-func (params *C.struct_pbc_param_s) WriteTo(w io.Writer) (n int64, err error) {
+func (params *paramsImpl) WriteTo(w io.Writer) (n int64, err error) {
count, err := io.WriteString(w, params.String())
return int64(count), err
}
-func (params *C.struct_pbc_param_s) String() string {
+func (params *paramsImpl) String() string {
var buf *C.char
var bufLen C.size_t
- if C.param_out_str_wrapper(&buf, &bufLen, params) == 0 {
+ if C.param_out_str_wrapper(&buf, &bufLen, params.data) == 0 {
return ""
}
str := C.GoStringN(buf, C.int(bufLen))
@@ -59,13 +60,13 @@ func (params *C.struct_pbc_param_s) String() string {
return str
}
-func clearParams(params *C.struct_pbc_param_s) {
+func clearParams(params *paramsImpl) {
println("clearparams")
- C.pbc_param_clear(params)
+ C.pbc_param_clear(params.data)
}
-func makeParams() *C.struct_pbc_param_s {
- params := &C.struct_pbc_param_s{}
+func makeParams() *paramsImpl {
+ params := ¶msImpl{data: &C.struct_pbc_param_s{}}
runtime.SetFinalizer(params, clearParams)
return params
}