build: separate compiler and libs

compiler/internal/lib/crypto/rand/rand.go

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rand
+
+// llgo:skipall
+import (
+	"io"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/openssl"
+	"github.com/qiniu/x/errors"
+)
+
+type rndReader struct{}
+
+func (rndReader) Read(p []byte) (n int, err error) {
+	return Read(p)
+}
+
+// Reader is a global, shared instance of a cryptographically
+// secure random number generator.
+var Reader io.Reader = rndReader{}
+
+type opensslError struct {
+	file     *c.Char
+	line     c.Int
+	flags    c.Int
+	function *c.Char
+	data     *c.Char
+	err      openssl.Errno
+}
+
+// [error code]:[library name]:[function name]:[reason string]:[[filename:line]]: [text message]
+func (p *opensslError) Error() string {
+	const bufsize = 1024
+	buf := (*c.Char)(c.Alloca(bufsize))
+	lib := openssl.ERRLibErrorString(p.err)
+	reason := openssl.ERRReasonErrorString(p.err)
+	n := uintptr(c.Snprintf(
+		buf, bufsize,
+		c.Str("%d:%s:%s:%s:[%s:%d]: "),
+		p.err, lib, p.function, reason, p.file, p.line))
+	n += c.Strlen(openssl.ERRErrorString(p.err, c.Advance(buf, n)))
+	return c.GoString(buf, n)
+}
+
+func getError() *opensslError {
+	ret := new(opensslError)
+	err := openssl.ERRGetErrorAll(&ret.file, &ret.line, &ret.function, &ret.data, &ret.flags)
+	if err == 0 {
+		return nil
+	}
+	return ret
+}
+
+func getErrors() error {
+	var errs errors.List
+	for openssl.ERRPeekError() != 0 {
+		errs.Add(getError())
+	}
+	return errs.ToError()
+}
+
+// Read is a helper function that calls Reader.Read using io.ReadFull.
+// On return, n == len(b) if and only if err == nil.
+func Read(b []byte) (n int, err error) {
+	if openssl.RANDBytes(b) != 0 {
+		return len(b), nil
+	}
+	return 0, getErrors()
+}
+
+/* TODO(xsw):
+// batched returns a function that calls f to populate a []byte by chunking it
+// into subslices of, at most, readMax bytes.
+func batched(f func([]byte) error, readMax int) func([]byte) error {
+	return func(out []byte) error {
+		for len(out) > 0 {
+			read := len(out)
+			if read > readMax {
+				read = readMax
+			}
+			if err := f(out[:read]); err != nil {
+				return err
+			}
+			out = out[read:]
+		}
+		return nil
+	}
+}
+*/

compiler/internal/lib/crypto/rand/util.go

@@ -0,0 +1,98 @@
+// Copyright 2011 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.
+
+package rand
+
+/* TODO(xsw):
+import (
+	"errors"
+	"io"
+	"math/big"
+)
+
+// Prime returns a number of the given bit length that is prime with high probability.
+// Prime will return error for any error returned by rand.Read or if bits < 2.
+func Prime(rand io.Reader, bits int) (*big.Int, error) {
+	if bits < 2 {
+		return nil, errors.New("crypto/rand: prime size must be at least 2-bit")
+	}
+
+	b := uint(bits % 8)
+	if b == 0 {
+		b = 8
+	}
+
+	bytes := make([]byte, (bits+7)/8)
+	p := new(big.Int)
+
+	for {
+		if _, err := io.ReadFull(rand, bytes); err != nil {
+			return nil, err
+		}
+
+		// Clear bits in the first byte to make sure the candidate has a size <= bits.
+		bytes[0] &= uint8(int(1<<b) - 1)
+		// Don't let the value be too small, i.e, set the most significant two bits.
+		// Setting the top two bits, rather than just the top bit,
+		// means that when two of these values are multiplied together,
+		// the result isn't ever one bit short.
+		if b >= 2 {
+			bytes[0] |= 3 << (b - 2)
+		} else {
+			// Here b==1, because b cannot be zero.
+			bytes[0] |= 1
+			if len(bytes) > 1 {
+				bytes[1] |= 0x80
+			}
+		}
+		// Make the value odd since an even number this large certainly isn't prime.
+		bytes[len(bytes)-1] |= 1
+
+		p.SetBytes(bytes)
+		if p.ProbablyPrime(20) {
+			return p, nil
+		}
+	}
+}
+
+// Int returns a uniform random value in [0, max). It panics if max <= 0.
+func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
+	if max.Sign() <= 0 {
+		panic("crypto/rand: argument to Int is <= 0")
+	}
+	n = new(big.Int)
+	n.Sub(max, n.SetUint64(1))
+	// bitLen is the maximum bit length needed to encode a value < max.
+	bitLen := n.BitLen()
+	if bitLen == 0 {
+		// the only valid result is 0
+		return
+	}
+	// k is the maximum byte length needed to encode a value < max.
+	k := (bitLen + 7) / 8
+	// b is the number of bits in the most significant byte of max-1.
+	b := uint(bitLen % 8)
+	if b == 0 {
+		b = 8
+	}
+
+	bytes := make([]byte, k)
+
+	for {
+		_, err = io.ReadFull(rand, bytes)
+		if err != nil {
+			return nil, err
+		}
+
+		// Clear bits in the first byte to increase the probability
+		// that the candidate is < max.
+		bytes[0] &= uint8(int(1<<b) - 1)
+
+		n.SetBytes(bytes)
+		if n.Cmp(max) < 0 {
+			return
+		}
+	}
+}
+*/