Merge pull request #687 from xushiwei/q

library syscall: linux fix

.github/workflows/go.yml

@@ -14,37 +14,65 @@ jobs:
   test:
     strategy:
       matrix:
-        # os: [macos-latest, ubuntu-latest]
+        os:
-        os: [macos-latest]
+          - macos-latest
+          - ubuntu-24.04
         llvm: [18]
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{matrix.os}}
     steps:
       - uses: actions/checkout@v4
 
-      - name: Update Homebrew
+      - name: Install dependencies
-        # needed as long as LLVM 18 is still fresh
-        if: matrix.llvm == 18 && startsWith(matrix.os, 'macos')
-        run: brew update
-      - name: Install LLVM ${{ matrix.llvm }} and bdw-gc
         if: startsWith(matrix.os, 'macos')
         run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }} bdw-gc
+          brew update
-          echo `brew --prefix llvm@${{ matrix.llvm }}`/bin >> $GITHUB_PATH
+          brew install llvm@${{matrix.llvm}} pkg-config bdw-gc openssl
-      - name: Install LLVM ${{ matrix.llvm }} and libgc-dev
+          echo "$(brew --prefix llvm@${{matrix.llvm}})/bin" >> $GITHUB_PATH
+
+          # Install optional deps for demos.
+          #
+          # NOTE: Keep this list updated as new deps are introduced.
+          opt_deps=(
+            cjson       # for github.com/goplus/llgo/c/cjson
+            sqlite      # for github.com/goplus/llgo/c/sqlite
+            python@3.12 # for github.com/goplus/llgo/py
+          )
+          brew install "${opt_deps[@]}"
+
+      - name: Install dependencies
         if: startsWith(matrix.os, 'ubuntu')
         run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ matrix.llvm }} main" | sudo tee /etc/apt/sources.list.d/llvm.list
+          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{matrix.llvm}} main" | sudo tee /etc/apt/sources.list.d/llvm.list
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
           sudo apt-get update
-          sudo apt-get install -y llvm-${{ matrix.llvm }}-dev clang-${{ matrix.llvm }} lld-${{ matrix.llvm }} pkg-config libgc-dev libcjson-dev libsqlite3-dev python3.11-dev
+          sudo apt-get install -y llvm-${{matrix.llvm}}-dev clang-${{matrix.llvm}} lld-${{matrix.llvm}} pkg-config libgc-dev libssl-dev zlib1g-dev
-          echo /usr/lib/llvm-${{ matrix.llvm }}/bin >> $GITHUB_PATH
+          echo "/usr/lib/llvm-${{matrix.llvm}}/bin" >> $GITHUB_PATH
-    
+
+          # Install optional deps for demos.
+          #
+          # NOTE: Keep this list updated as new deps are introduced.
+          opt_deps=(
+            libcjson-dev   # for github.com/goplus/llgo/c/cjson
+            libsqlite3-dev # for github.com/goplus/llgo/c/sqlite
+            python3.12-dev # for github.com/goplus/llgo/py
+          )
+          sudo apt-get install -y "${opt_deps[@]}"
+
+      - name: Install further optional dependencies for demos
+        run: |
+          wget -P ./_demo/llama2-c https://huggingface.co/karpathy/tinyllamas/resolve/main/stories15M.bin
+          py_deps=(
+            numpy # for github.com/goplus/llgo/py/numpy
+            torch # for github.com/goplus/llgo/py/torch
+          )
+          pip3 install --break-system-packages "${py_deps[@]}"
+
       - name: Clang information
         run: |
           echo $PATH
           which clang
           clang --version
-        
+
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
@@ -54,28 +82,26 @@ jobs:
         run: go build -v ./...
 
       - name: Test
-        if: matrix.os != 'macos-latest'
+        if: ${{!startsWith(matrix.os, 'macos')}}
         run: go test -v ./...
 
       - name: Test with coverage
-        if: matrix.os == 'macos-latest'
+        if: startsWith(matrix.os, 'macos')
         run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
 
       - name: Install
         run: go install ./...
-      
+
       - name: LLGO tests
-        if: matrix.os != 'ubuntu-latest'
+        if: ${{!startsWith(matrix.os, 'ubuntu')}}
         run: |
-          echo "Test result on ${{ matrix.os }} with LLVM ${{ matrix.llvm }}" > result.md
+          echo "Test result on ${{matrix.os}} with LLVM ${{matrix.llvm}}" > result.md
-          LLGOROOT=$PWD bash .github/workflows/test_llgo.sh
+          bash .github/workflows/test_llgo.sh
-      
+
-      - name: Test _demo and _pydemo
+      - name: Test demos
-        run: |
+        continue-on-error: true
-          set +e
+        run: bash .github/workflows/test_demo.sh
-          LLGOROOT=$PWD bash .github/workflows/test_demo.sh
+
-          exit 0
-      
       - name: Show test result
         run: cat result.md
 
@@ -84,10 +110,10 @@ jobs:
         if: false
         with:
           filePath: result.md
-          comment_tag: test-result-on-${{ matrix.os }}-with-llvm-${{ matrix.llvm }}
+          comment_tag: test-result-on-${{matrix.os}}-with-llvm-${{matrix.llvm}}
 
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v4
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
+          token: ${{secrets.CODECOV_TOKEN}}
           slug: goplus/llgo

.github/workflows/test_demo.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -e
 
 # llgo run subdirectories under _demo and _pydemo
 total=0
@@ -8,7 +9,7 @@ for d in ./_demo/* ./_pydemo/*; do
   total=$((total+1))
   if [ -d "$d" ]; then
     echo "Testing $d"
-    if ! llgo run "$d"; then
+    if ! (cd "$d" && llgo run .); then
       echo "FAIL"
       failed=$((failed+1))
       failed_cases="$failed_cases\n* :x: $d"

.github/workflows/test_llgo.sh

@@ -1,8 +1,6 @@
 #!/bin/bash
 set -e
 
-export LLGOROOT=$PWD
-
 testcmd=/tmp/test
 llgo build -o $testcmd ./c/bdwgc/_test
 cases=$($testcmd)

.goreleaser.yaml

@@ -20,8 +20,8 @@ builds:
     flags:
       - -tags=darwin,amd64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/local/opt/llvm@18/bin/llvm-config
     env:
       - CC=o64-clang
@@ -36,8 +36,8 @@ builds:
     flags:
       - -tags=darwin,arm64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/opt/homebrew/opt/llvm@18/bin/llvm-config
     env:
       - CC=oa64-clang
@@ -52,8 +52,8 @@ builds:
     flags:
       - -tags=linux,amd64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
     env:
       - CC=x86_64-linux-gnu-gcc
@@ -68,8 +68,8 @@ builds:
     flags:
       - -tags=linux,arm64,byollvm
     ldflags:
-      - -X github.com/goplus/llgo/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
-      - -X github.com/goplus/llgo/xtool/env.buildDate={{.Date}}
+      - -X github.com/goplus/llgo/x/env.buildTime={{.Date}}
       - -X github.com/goplus/llgo/xtool/env/llvm.ldLLVMConfigBin=/usr/lib/llvm-18/bin/llvm-config
     env:
       - CC=aarch64-linux-gnu-gcc

README.md

@@ -32,8 +32,9 @@ LLGo is compatible with C and Python through the language's **Application Binary
 You can import a C/C++ standard library in LLGo!
 
 * [c](https://pkg.go.dev/github.com/goplus/llgo/c)
-* [c/os](https://pkg.go.dev/github.com/goplus/llgo/c/os)
 * [c/syscall](https://pkg.go.dev/github.com/goplus/llgo/c/syscall)
+* [c/sys](https://pkg.go.dev/github.com/goplus/llgo/c/sys)
+* [c/os](https://pkg.go.dev/github.com/goplus/llgo/c/os)
 * [c/math](https://pkg.go.dev/github.com/goplus/llgo/c/math)
 * [c/math/cmplx](https://pkg.go.dev/github.com/goplus/llgo/c/math/cmplx)
 * [c/math/rand](https://pkg.go.dev/github.com/goplus/llgo/c/math/rand)
@@ -41,7 +42,7 @@ You can import a C/C++ standard library in LLGo!
 * [c/pthread/sync](https://pkg.go.dev/github.com/goplus/llgo/c/pthread/sync)
 * [c/sync/atomic](https://pkg.go.dev/github.com/goplus/llgo/c/sync/atomic)
 * [c/time](https://pkg.go.dev/github.com/goplus/llgo/c/time)
-* [c/socket](https://pkg.go.dev/github.com/goplus/llgo/c/socket)
+* [c/net](https://pkg.go.dev/github.com/goplus/llgo/c/net)
 * [cpp/std](https://pkg.go.dev/github.com/goplus/llgo/cpp/std)
 
 Here is a simple example:
@@ -213,13 +214,16 @@ The currently supported libraries include:
 * [c/bdwgc](https://pkg.go.dev/github.com/goplus/llgo/c/bdwgc)
 * [c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson)
 * [c/clang](https://pkg.go.dev/github.com/goplus/llgo/c/clang)
+* [c/libuv](https://pkg.go.dev/github.com/goplus/llgo/c/libuv)
 * [c/llama2](https://pkg.go.dev/github.com/goplus/llgo/c/llama2)
 * [c/lua](https://pkg.go.dev/github.com/goplus/llgo/c/lua)
 * [c/neco](https://pkg.go.dev/github.com/goplus/llgo/c/neco)
+* [c/openssl](https://pkg.go.dev/github.com/goplus/llgo/c/openssl)
 * [c/raylib](https://pkg.go.dev/github.com/goplus/llgo/c/raylib)
 * [c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite)
 * [c/zlib](https://pkg.go.dev/github.com/goplus/llgo/c/zlib)
 * [cpp/inih](https://pkg.go.dev/github.com/goplus/llgo/cpp/inih)
+* [cpp/llvm](https://pkg.go.dev/github.com/goplus/llgo/cpp/llvm)
 
 Here are some examples related to them:
 
@@ -240,7 +244,7 @@ All Go syntax (not including `cgo`) is already supported. Here are some examples
 * [goroutine](_demo/goroutine/goroutine.go): goroutine demo
 
 
-## Defer
+### Defer
 
 LLGo `defer` does not support usage in loops. This is not a bug but a feature, because we think that using `defer` in a loop is a very unrecommended practice.
 
@@ -265,17 +269,25 @@ Here are the Go packages that can be imported correctly:
 * [unicode/utf8](https://pkg.go.dev/unicode/utf8)
 * [unicode/utf16](https://pkg.go.dev/unicode/utf16)
 * [math](https://pkg.go.dev/math)
+* [math/big](https://pkg.go.dev/math/big) (partially)
 * [math/bits](https://pkg.go.dev/math/bits)
 * [math/cmplx](https://pkg.go.dev/math/cmplx)
+* [math/rand](https://pkg.go.dev/math/rand)
+* [net/url](https://pkg.go.dev/net/url)
 * [errors](https://pkg.go.dev/errors)
 * [context](https://pkg.go.dev/context)
 * [io](https://pkg.go.dev/io)
 * [io/fs](https://pkg.go.dev/io/fs)
+* [io/ioutil](https://pkg.go.dev/io/ioutil)
 * [log](https://pkg.go.dev/log)
 * [flag](https://pkg.go.dev/flag)
 * [sort](https://pkg.go.dev/sort)
-* [strconv](https://pkg.go.dev/strconv)
+* [bytes](https://pkg.go.dev/bytes)
+* [bufio](https://pkg.go.dev/bufio)
 * [strings](https://pkg.go.dev/strings)
+* [strconv](https://pkg.go.dev/strconv)
+* [path](https://pkg.go.dev/path)
+* [path/filepath](https://pkg.go.dev/path/filepath)
 * [sync/atomic](https://pkg.go.dev/sync/atomic)
 * [sync](https://pkg.go.dev/sync) (partially)
 * [syscall](https://pkg.go.dev/syscall) (partially)
@@ -285,19 +297,41 @@ Here are the Go packages that can be imported correctly:
 * [fmt](https://pkg.go.dev/fmt) (partially)
 * [reflect](https://pkg.go.dev/reflect) (partially)
 * [time](https://pkg.go.dev/time) (partially)
+* [encoding](https://pkg.go.dev/encoding)
+* [encoding/binary](https://pkg.go.dev/encoding/binary)
+* [encoding/hex](https://pkg.go.dev/encoding/hex)
+* [encoding/base32](https://pkg.go.dev/encoding/base32)
+* [encoding/base64](https://pkg.go.dev/encoding/base64)
+* [encoding/csv](https://pkg.go.dev/encoding/csv)
+* [hash](https://pkg.go.dev/hash)
+* [hash/adler32](https://pkg.go.dev/hash/adler32)
+* [hash/crc32](https://pkg.go.dev/hash/crc32) (partially)
+* [hash/crc64](https://pkg.go.dev/hash/crc64)
+* [crypto](https://pkg.go.dev/crypto)
+* [crypto/md5](https://pkg.go.dev/crypto/md5)
+* [crypto/sha1](https://pkg.go.dev/crypto/sha1)
+* [crypto/sha256](https://pkg.go.dev/crypto/sha256)
+* [crypto/sha512](https://pkg.go.dev/crypto/sha512) (partially)
+* [crypto/hmac](https://pkg.go.dev/crypto/hmac) (partially)
+* [crypto/rand](https://pkg.go.dev/crypto/rand) (partially)
+* [crypto/subtle](https://pkg.go.dev/crypto/subtle) (partially)
+* [regexp](https://pkg.go.dev/regexp)
+* [regexp/syntax](https://pkg.go.dev/regexp/syntax)
+* [go/token](https://pkg.go.dev/go/token)
+* [go/scanner](https://pkg.go.dev/go/scanner)
 
 
 ## Dependencies
 
-- [Go 1.20+](https://go.dev) (build only)
+- [Go 1.20+](https://go.dev)
 - [LLVM 18](https://llvm.org)
 - [LLD 18](https://lld.llvm.org)
 - [Clang 18](https://clang.llvm.org)
 - [pkg-config 0.29+](https://www.freedesktop.org/wiki/Software/pkg-config/)
 - [bdwgc/libgc 8.0+](https://www.hboehm.info/gc/)
-- [cJSON 1.7+](https://github.com/DaveGamble/cJSON) (optional, for [github.com/goplus/llgo/c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson))
+- [OpenSSL 3.0+](https://www.openssl.org/)
-- [SQLite 3](https://www.sqlite.org) (optional, for [github.com/goplus/llgo/c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite))
+- [zlib 1.2+](https://www.zlib.net)
-- [Python 3.11+](https://www.python.org) (optional, for [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
+- [Python 3.12+](https://www.python.org) (optional, for [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
 
 ## How to install
 
@@ -306,10 +340,9 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 ### on macOS
 
 ```sh
-brew update # execute if needed
+brew update
-brew install llvm@18 pkg-config libgc
+brew install llvm@18 pkg-config bdw-gc openssl
-brew install cjson sqlite python@3.12 # optional
+brew install python@3.12 # optional
-export PATH=$(brew --prefix llvm@18)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
 go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
@@ -318,10 +351,9 @@ go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```sh
 echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-18 main" | sudo tee /etc/apt/sources.list.d/llvm.list
 wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-sudo apt-get update # execute if needed
+sudo apt-get update
-sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev
+sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev libssl-dev zlib1g-dev
-sudo apt-get install -y libcjson-dev libsqlite3-dev python3.12-dev # optional
+sudo apt-get install -y python3.12-dev # optional
-export PATH=/usr/lib/llvm-18/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
 go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 

_cmptest/_bigsqrt2/sqrt2.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/big"
+)
+
+func main() {
+	// We'll do computations with 200 bits of precision in the mantissa.
+	const prec = 200
+
+	// Compute the square root of 2 using Newton's Method. We start with
+	// an initial estimate for sqrt(2), and then iterate:
+	//     x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )
+
+	// Since Newton's Method doubles the number of correct digits at each
+	// iteration, we need at least log_2(prec) steps.
+	steps := int(math.Log2(prec))
+
+	// Initialize values we need for the computation.
+	two := new(big.Float).SetPrec(prec).SetInt64(2)
+	half := new(big.Float).SetPrec(prec).SetFloat64(0.5)
+
+	// Use 1 as the initial estimate.
+	x := new(big.Float).SetPrec(prec).SetInt64(1)
+
+	// We use t as a temporary variable. There's no need to set its precision
+	// since big.Float values with unset (== 0) precision automatically assume
+	// the largest precision of the arguments when used as the result (receiver)
+	// of a big.Float operation.
+	t := new(big.Float)
+
+	// Iterate.
+	for i := 0; i <= steps; i++ {
+		t.Quo(two, x)  // t = 2.0 / x_n
+		t.Add(x, t)    // t = x_n + (2.0 / x_n)
+		x.Mul(half, t) // x_{n+1} = 0.5 * t
+	}
+
+	// We can use the usual fmt.Printf verbs since big.Float implements fmt.Formatter
+	fmt.Printf("sqrt(2) = %.50f\n", x)
+
+	// Print the error between 2 and x*x.
+	t.Mul(x, x) // t = x*x
+	fmt.Printf("error = %e\n", t.Sub(two, t))
+}

_cmptest/_goparsedemo/parse.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"go/parser"
+	"go/token"
+)
+
+func main() {
+	fset := token.NewFileSet() // positions are relative to fset
+
+	src := `package foo
+
+import (
+	"fmt"
+	"time"
+)
+
+func bar() {
+	fmt.Println(time.Now())
+}`
+
+	// Parse src but stop after processing the imports.
+	f, err := parser.ParseFile(fset, "", src, parser.ImportsOnly)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	// Print the imports from the file's AST.
+	for _, s := range f.Imports {
+		fmt.Println(s.Path.Value)
+	}
+}

_cmptest/_jsondemo/json.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"unsafe"
+)
+
+func main() {
+	s := `{"name":"math","items":[{"name":"sqrt","sig":"(x, /)"},{"name":"pi"}]}`
+	data := unsafe.Slice(unsafe.StringData(s), len(s))
+	var v any
+	json.Unmarshal(data, &v)
+	b, _ := json.MarshalIndent(v, "", "  ")
+	fmt.Println(string(b))
+}

_cmptest/_timeout/timer.go

@@ -13,7 +13,7 @@ func main() {
 	select {
 	case m := <-c:
 		handle(m)
-	case <-time.After(10 * time.Second):
+	case <-time.After(time.Second / 10):
 		fmt.Println("timed out")
 	}
 }

_cmptest/base64demo/base64.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"encoding/base32"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"log"
+)
+
+func base64Demo() {
+	msg := "Hello, 世界"
+	encoded := base64.StdEncoding.EncodeToString([]byte(msg))
+	fmt.Println(encoded)
+	decoded, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		fmt.Println("decode error:", err)
+		return
+	}
+	fmt.Println(string(decoded))
+}
+
+func base32Demo() {
+	str := "JBSWY3DPFQQHO33SNRSCC==="
+	dst := make([]byte, base32.StdEncoding.DecodedLen(len(str)))
+	n, err := base32.StdEncoding.Decode(dst, []byte(str))
+	if err != nil {
+		fmt.Println("decode error:", err)
+		return
+	}
+	dst = dst[:n]
+	fmt.Printf("%q\n", dst)
+}
+
+func hexDemo() {
+	const s = "48656c6c6f20476f7068657221"
+	decoded, err := hex.DecodeString(s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("%s\n", decoded)
+
+}
+func main() {
+	base64Demo()
+	base32Demo()
+	hexDemo()
+}

_cmptest/bigintdemo/fib.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"math/big"
+)
+
+func fib() {
+	// Initialize two big ints with the first two numbers in the sequence.
+	a := big.NewInt(0)
+	b := big.NewInt(1)
+
+	// Initialize limit as 10^99, the smallest integer with 100 digits.
+	var limit big.Int
+	limit.Exp(big.NewInt(10), big.NewInt(99), nil)
+
+	// Loop while a is smaller than 1e100.
+	for a.Cmp(&limit) < 0 {
+		// Compute the next Fibonacci number, storing it in a.
+		a.Add(a, b)
+		// Swap a and b so that b is the next number in the sequence.
+		a, b = b, a
+	}
+	fmt.Println(a) // 100-digit Fibonacci number
+}
+
+func abs() {
+	a := big.NewInt(64)
+	b := big.NewInt(-52)
+	a.Set(b)
+	a.Abs(a)
+	a.Set(big.NewInt(-164))
+	a.Abs(a)
+	fmt.Println("value: ", a.String())
+}
+
+func neg() {
+	fmt.Println("value: ", big.NewInt(-64).Neg(big.NewInt(-64)))
+	fmt.Println("value: ", big.NewInt(64).Neg(big.NewInt(64)))
+	fmt.Println("value: ", big.NewInt(0).Neg(big.NewInt(0)))
+}
+
+func calc() {
+	a := big.NewInt(64)
+	b := big.NewInt(-52)
+	c := big.NewInt(54)
+	fmt.Println("value:", a.Add(a, b))
+	fmt.Println("value:", a.Sub(b, c))
+	d := big.NewInt(10)
+	e := big.NewInt(4)
+	fmt.Println("value:", d.Mul(d, e))
+}
+
+func bitop() {
+	a := big.NewInt(4)
+	fmt.Println("value:", a.Lsh(a, 1))
+	b := big.NewInt(16)
+	fmt.Println("value:", b.Rsh(b, 2))
+}
+
+func main() {
+	bitop()
+}

_cmptest/crcdemo/crc.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"hash/adler32"
+	"hash/crc32"
+	"hash/crc64"
+)
+
+func crc64Demo() {
+	crc := crc64.MakeTable(crc64.ECMA)
+	fmt.Printf("%016x\n", crc64.Checksum([]byte("Hello world"), crc))
+}
+
+func crc32Demo() {
+	crc32q := crc32.MakeTable(crc32.IEEE)
+	fmt.Printf("%08x\n", crc32.Checksum([]byte("Hello world"), crc32q))
+}
+
+func adler32Demo() {
+	fmt.Printf("%08x\n", adler32.Checksum([]byte("Hello world")))
+}
+
+func main() {
+	adler32Demo()
+	crc32Demo()
+	crc64Demo()
+}

_cmptest/csvdemo/csv.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+)
+
+func main() {
+	in := `first_name,last_name,username
+"Rob","Pike",rob
+Ken,Thompson,ken
+"Robert","Griesemer","gri"
+`
+	r := csv.NewReader(strings.NewReader(in))
+
+	for {
+		record, err := r.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		fmt.Println(record)
+	}
+}

_cmptest/envexpand/expand.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	mapper := func(placeholderName string) string {
+		switch placeholderName {
+		case "DAY_PART":
+			return "morning"
+		case "NAME":
+			return "Gopher"
+		}
+		return ""
+	}
+
+	fmt.Println(os.Expand("Good ${DAY_PART}, $NAME!", mapper))
+}

_cmptest/goscandemo/scan.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"go/scanner"
+	"go/token"
+)
+
+func main() {
+	// src is the input that we want to tokenize.
+	src := []byte("cos(x) + 1i*sin(x) // Euler")
+
+	// Initialize the scanner.
+	var s scanner.Scanner
+	fset := token.NewFileSet()                      // positions are relative to fset
+	file := fset.AddFile("", fset.Base(), len(src)) // register input "file"
+	s.Init(file, src, nil /* no error handler */, scanner.ScanComments)
+
+	// Repeated calls to Scan yield the token sequence found in the input.
+	for {
+		pos, tok, lit := s.Scan()
+		if tok == token.EOF {
+			break
+		}
+		fmt.Printf("%s\t%s\t%q\n", fset.Position(pos), tok, lit)
+	}
+}

_cmptest/hmacdemo/hmac.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := hmac.New(sha1.New, []byte("<key>"))
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/ioutildemo/ioutil.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"strings"
+)
+
+func main() {
+	r := strings.NewReader("Go is a general-purpose language designed with systems programming in mind.")
+
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("%s\n", b)
+}

_cmptest/md5demo/md5.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"crypto"
+	"crypto/md5"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := md5.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x\n", h.Sum(nil))
+
+	h = crypto.MD5.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x\n", h.Sum(nil))
+}

_cmptest/osexec/exec.go

@@ -1,9 +1,12 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"runtime"
+
+	"github.com/goplus/llgo/xtool/env/llvm"
 )
 
 func main() {
@@ -15,4 +18,7 @@ func main() {
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	cmd.Run()
+
+	dir := llvm.New("").BinDir()
+	fmt.Println(dir)
 }

_cmptest/pipedemo/pipe.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+func main() {
+	data := []byte("This is some data that needs to be stored in Body.")
+	pr, pw := io.Pipe()
+	go func() {
+		defer pw.Close()
+		if _, err := pw.Write(data); err != nil {
+			fmt.Println("Error writing to pipe:", err)
+			return
+		}
+	}()
+	defer pr.Close()
+
+	readData, err := io.ReadAll(pr)
+	if err != nil {
+		fmt.Println("Error reading from Body:", err)
+		return
+	}
+	fmt.Println("Body:", string(readData))
+}

_cmptest/printfdemo/demo.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/xtool/nm"
+)
+
+func main() {
+	sym := nm.Symbol{Name: "abc", Type: nm.Text}
+	fmt.Printf("%016x %c %s\n", sym.Addr, sym.Type, sym.Name)
+}

_cmptest/readfiledemo/readf.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	fileName := "err.log"
+	os.WriteFile(fileName, []byte("123"), 0644)
+
+	_, err := os.Stat(fileName)
+	if os.IsNotExist(err) {
+		fmt.Fprintf(os.Stderr, "File %s not found\n", fileName)
+		return
+	}
+
+	data, err := os.ReadFile(fileName)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ReadFile: %v\n", err)
+		return
+	}
+
+	fmt.Printf("%s\n", data)
+}

_cmptest/regexdemo/regex.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/xtool/env"
+)
+
+func main() {
+	fmt.Println(env.ExpandEnv("$(pkg-config --libs bdw-gc)"))
+}

_cmptest/sha1demo/sha1.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"crypto/sha1"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := sha1.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/sha256demo/sha256.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := sha256.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/sha512demo/sha512.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"crypto/sha512"
+	"fmt"
+	"io"
+)
+
+func main() {
+	h := sha512.New()
+	io.WriteString(h, "The fog is getting thicker!")
+	io.WriteString(h, "And Leon's getting laaarger!")
+	fmt.Printf("%x", h.Sum(nil))
+}

_cmptest/urldemo/url.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/url"
+)
+
+func main() {
+	u, err := url.Parse("http://foo.example.com/foo?bar=1")
+	if err != nil {
+		log.Fatal(err)
+	}
+	u.Scheme = "https"
+	u.Host = "bar.example.com"
+	q := u.Query()
+	q.Set("bar", "2")
+	u.RawQuery = q.Encode()
+	fmt.Println(u)
+}

_demo/crand/rand.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/math/rand"
+	"github.com/goplus/llgo/c/time"
+)
+
+func fastrand64() uint64 {
+	v1 := uint64(rand.Random())
+	v2 := uint64(rand.Random())
+	return v1 ^ (v2 << 32)
+}
+
+func main() {
+	rand.Srand(c.Uint(time.Time(nil)))
+	fmt.Printf("%x\n", rand.Rand())
+	fmt.Printf("%x\n", rand.Rand())
+
+	rand.Srandom(c.Uint(time.Time(nil)))
+	fmt.Printf("%x\n", rand.Random())
+	fmt.Printf("%x\n", rand.Random())
+	fmt.Printf("%x\n", fastrand64())
+}

_demo/llama2-c/run.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/llama2"
+	"github.com/goplus/llgo/c/time"
 )
 
 func main() {
@@ -11,7 +12,7 @@ func main() {
 	var tokenizerPath *c.Char = c.Str("tokenizer.bin")
 	var temperature, topp c.Float = 1.0, 0.9
 	var steps c.Int = 256
-	var rngSeed uint64 = uint64(c.Time(nil))
+	var rngSeed uint64 = uint64(time.Time(nil))
 
 loop: // parse command line arguments
 	for {

_demo/netdbdemo/netdb.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
+)
+
+func main() {
+	var hints net.AddrInfo
+	hints.Family = net.AF_UNSPEC
+	hints.SockType = net.SOCK_STREAM
+
+	host := "httpbin.org"
+	port := "80"
+
+	var result *net.AddrInfo
+	c.Printf(c.Str("%d\n"), net.Getaddrinfo(c.Str(host), c.Str(port), &hints, &result))
+
+	c.Printf(c.Str("%d\n"), net.Freeaddrinfo(result))
+}

_demo/rand/rand.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/math/rand"
-)
-
-func main() {
-	var s c.Uint = 6
-	rand.Srand(s)
-	rr := rand.RandR(&s)
-	r := rand.Rand()
-	println("r:", r)
-	println("rr:", rr)
-}

_demo/randcrypt/rand.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"crypto/rand"
+	"fmt"
+)
+
+func main() {
+	c := 10
+	b := make([]byte, c)
+	_, err := rand.Read(b)
+	if err != nil {
+		fmt.Println("error:", err)
+		return
+	}
+	// The slice should now contain random bytes instead of only zeroes.
+	fmt.Printf("%x\n", b)
+}

_demo/randdemo/rand.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+func main() {
+	fmt.Println(rand.Intn(100))
+	fmt.Println(rand.Intn(100))
+	fmt.Println(rand.Intn(100))
+}

_demo/socket/client/client.go

@@ -4,27 +4,27 @@ import (
 	"unsafe"
 
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
 	"github.com/goplus/llgo/c/os"
-	"github.com/goplus/llgo/c/socket"
 )
 
 func main() {
-	sockfd := socket.Socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+	sockfd := net.Socket(net.AF_INET, net.SOCK_STREAM, 0)
 	msg := c.Str("Hello, World!")
 	defer os.Close(sockfd)
 
-	server := socket.GetHostByName(c.Str("localhost"))
+	server := net.GetHostByName(c.Str("localhost"))
 	if server == nil {
 		c.Perror(c.Str("hostname get error"))
 		return
 	}
 
-	servAddr := &socket.SockaddrIn{}
+	servAddr := &net.SockaddrIn{}
-	servAddr.Family = socket.AF_INET
+	servAddr.Family = net.AF_INET
-	servAddr.Port = socket.Htons(uint16(1234))
+	servAddr.Port = net.Htons(uint16(1234))
 	c.Memcpy(unsafe.Pointer(&servAddr.Addr.Addr), unsafe.Pointer(*server.AddrList), uintptr(server.Length))
 
-	if res := socket.Connect(sockfd, (*socket.SockAddr)(unsafe.Pointer(servAddr)), c.Uint(16)); res < 0 {
+	if res := net.Connect(sockfd, (*net.SockAddr)(unsafe.Pointer(servAddr)), c.Uint(16)); res < 0 {
 		c.Perror(c.Str("connect error"))
 		return
 	}

_demo/socket/server/server.go

@@ -4,36 +4,36 @@ import (
 	"unsafe"
 
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
 	"github.com/goplus/llgo/c/os"
-	"github.com/goplus/llgo/c/socket"
 )
 
 func main() {
 	var buffer [256]c.Char
 
-	sockfd := socket.Socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+	sockfd := net.Socket(net.AF_INET, net.SOCK_STREAM, 0)
 	defer os.Close(sockfd)
 
-	servAddr := &socket.SockaddrIn{
+	servAddr := &net.SockaddrIn{
-		Family: socket.AF_INET,
+		Family: net.AF_INET,
-		Port:   socket.Htons(uint16(1234)),
+		Port:   net.Htons(uint16(1234)),
-		Addr:   socket.InAddr{Addr: 0x00000000},
+		Addr:   net.InAddr{Addr: 0x00000000},
 		Zero:   [8]c.Char{0, 0, 0, 0, 0, 0, 0, 0},
 	}
-	if res := socket.Bind(sockfd, servAddr, c.Uint(unsafe.Sizeof(*servAddr))); res < 0 {
+	if res := net.Bind(sockfd, servAddr, c.Uint(unsafe.Sizeof(*servAddr))); res < 0 {
 		c.Perror(c.Str("bind error"))
 		return
 	}
 
-	if socket.Listen(sockfd, 5) < 0 {
+	if net.Listen(sockfd, 5) < 0 {
 		c.Printf(c.Str("listen error"))
 		return
 	}
 	c.Printf(c.Str("Listening on port 1234...\n"))
 
-	cliAddr, clilen := &socket.SockaddrIn{}, c.Uint(unsafe.Sizeof(servAddr))
+	cliAddr, clilen := &net.SockaddrIn{}, c.Uint(unsafe.Sizeof(servAddr))
 
-	newsockfd := socket.Accept(sockfd, cliAddr, &clilen)
+	newsockfd := net.Accept(sockfd, cliAddr, &clilen)
 	defer os.Close(newsockfd)
 	c.Printf(c.Str("Connection accepted."))
 

c/c.go

@@ -28,6 +28,7 @@ const (
 )
 
 type (
+	Void    = [0]byte
 	Char    = int8
 	Float   = float32
 	Double  = float64
@@ -78,6 +79,9 @@ func AllocaNew[T any]() *T { return nil }
 //go:linkname Malloc C.malloc
 func Malloc(size uintptr) Pointer
 
+//go:linkname Calloc C.calloc
+func Calloc(num uintptr, size uintptr) Pointer
+
 //go:linkname Free C.free
 func Free(ptr Pointer)
 
@@ -226,9 +230,6 @@ func Perror(s *Char)
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Time C.time
-func Time(*int32) int32
-
 //go:linkname Usleep C.usleep
 func Usleep(useconds Uint) Int
 

c/cjson/_demo/mkjson/mkjson.go

@@ -22,6 +22,22 @@ func main() {
 
 	mod.SetItem(c.Str("items"), syms)
 
-	c.Printf(c.Str("%s\n"), mod.CStr())
+	cstr := mod.CStr()
+	str := c.GoString(cstr)
+	c.Printf(c.Str("%s\n"), cstr)
+	cjson.FreeCStr(cstr)
+
+	mod.Delete()
+
+	cjsonLoad(str)
+}
+
+func cjsonLoad(str string) {
+	mod := cjson.ParseString(str)
+
+	cstr := mod.Print()
+	c.Printf(c.Str("%s\n"), cstr)
+	cjson.FreeCStr(cstr)
+
 	mod.Delete()
 }

c/cjson/cjson.go

@@ -17,7 +17,7 @@
 package cjson
 
 import (
-	_ "unsafe"
+	"unsafe"
 
 	"github.com/goplus/llgo/c"
 )
@@ -31,6 +31,20 @@ type JSON struct {
 	Unused [0]byte
 }
 
+//go:linkname Parse C.cJSON_Parse
+func Parse(value *c.Char) *JSON
+
+//go:linkname ParseWithLength C.cJSON_ParseWithLength
+func ParseWithLength(value *byte, valueLength uintptr) *JSON
+
+func ParseBytes(value []byte) *JSON {
+	return ParseWithLength(unsafe.SliceData(value), uintptr(len(value)))
+}
+
+func ParseString(value string) *JSON {
+	return ParseWithLength(unsafe.StringData(value), uintptr(len(value)))
+}
+
 //go:linkname Null C.cJSON_CreateNull
 func Null() *JSON
 
@@ -119,3 +133,21 @@ func (o *JSON) PrintUnformatted() *c.Char { return nil }
 //
 // llgo:link (*JSON).PrintBuffered C.cJSON_PrintBuffered
 func (o *JSON) PrintBuffered(prebuffer c.Int, fmt c.Int) *c.Char { return nil }
+
+// llgo:link (*JSON).GetObjectItemCaseSensitive C.cJSON_GetObjectItemCaseSensitive
+func (o *JSON) GetObjectItemCaseSensitive(key *c.Char) *JSON { return nil }
+
+// llgo:link (*JSON).GetArraySize C.cJSON_GetArraySize
+func (o *JSON) GetArraySize() c.Int { return 0 }
+
+// llgo:link (*JSON).GetArrayItem C.cJSON_GetArrayItem
+func (o *JSON) GetArrayItem(index c.Int) *JSON { return nil }
+
+// llgo:link (*JSON).GetStringValue C.cJSON_GetStringValue
+func (o *JSON) GetStringValue() *c.Char { return nil }
+
+//go:linkname Free C.cJSON_free
+func Free(ptr unsafe.Pointer)
+
+//go:linkname FreeCStr C.cJSON_free
+func FreeCStr(*c.Char)

c/clang/_demo/castdump/astdump.go

@@ -1,61 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/c/clang"
-)
-
-func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
-	depth := *(*c.Uint)(clientData)
-	printAST(cursor, depth+1)
-	return clang.ChildVisit_Continue
-}
-
-func printAST(cursor clang.Cursor, depth c.Uint) {
-	cursorKind := cursor.Kind.String()
-
-	cursorSpelling := cursor.String()
-
-	for i := c.Uint(0); i < depth; i++ {
-		c.Fputs(c.Str("  "), c.Stdout)
-	}
-
-	c.Printf(c.Str("%s: %s\n"), cursorKind.CStr(), cursorSpelling.CStr())
-
-	cursorKind.Dispose()
-	cursorSpelling.Dispose()
-
-	clang.VisitChildren(cursor, visit, c.Pointer(&depth))
-}
-
-func main() {
-	if c.Argc != 2 {
-		fmt.Fprintln(os.Stderr, "Usage: castdump <headerFile>")
-		return
-	}
-	sourceFile := *c.Advance(c.Argv, 1)
-
-	index := clang.CreateIndex(0, 0)
-
-	unit := index.ParseTranslationUnit(
-		sourceFile,
-		nil, 0,
-		nil, 0,
-		clang.TranslationUnit_None,
-	)
-
-	if unit == nil {
-		println("Unable to parse translation unit. Quitting.")
-		c.Exit(1)
-	}
-
-	cursor := unit.Cursor()
-
-	printAST(cursor, 0)
-
-	unit.Dispose()
-	index.Dispose()
-}

c/clang/_demo/symboldump/symboldump.go

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/clang"
+)
+
+type Context struct {
+	namespaceName string
+	className     string
+	unit          *clang.TranslationUnit
+}
+
+func newContext() *Context {
+	return &Context{}
+}
+
+func (c *Context) setNamespaceName(name string) {
+	c.namespaceName = name
+}
+
+func (c *Context) setClassName(name string) {
+	c.className = name
+}
+
+func (c *Context) setUnit(unit *clang.TranslationUnit) {
+	c.unit = unit
+}
+
+var context = newContext()
+
+func printCursorLocation(cursor clang.Cursor) {
+	loc := cursor.Location()
+	var file clang.File
+	var line, column c.Uint
+
+	loc.SpellingLocation(&file, &line, &column, nil)
+	filename := file.FileName()
+	defer filename.Dispose()
+
+	c.Printf(c.Str("%s:%d:%d\n"), filename.CStr(), line, column)
+}
+
+func printMarcoInfo(cursor clang.Cursor) {
+	printCursorLocation(cursor)
+	name := cursor.String()
+	c.Printf(c.Str("Marco Name: %s\n"), name.CStr())
+	ran := cursor.Extent()
+	var numTokens c.Uint
+	var tokens *clang.Token
+	context.unit.Tokenize(ran, &tokens, &numTokens)
+	c.Printf(c.Str("Content: "))
+
+	tokensSlice := unsafe.Slice(tokens, int(numTokens))
+	for _, tok := range tokensSlice {
+		tokStr := context.unit.Token(tok)
+		c.Printf(c.Str("%s "), tokStr.CStr())
+		tokStr.Dispose()
+	}
+
+	c.Printf(c.Str("\n"))
+	println("--------------------------------")
+}
+func printFuncInfo(cursor clang.Cursor) {
+	printCursorLocation(cursor)
+
+	cursorStr := cursor.String()
+	symbol := cursor.Mangling()
+	defer symbol.Dispose()
+	defer cursorStr.Dispose()
+
+	if context.namespaceName != "" && context.className != "" {
+		fmt.Printf("%s:%s:", context.namespaceName, context.className)
+	} else if context.namespaceName != "" {
+		fmt.Printf("%s:", context.namespaceName)
+	}
+	c.Printf(c.Str("%s\n"), cursorStr.CStr())
+
+	if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
+		c.Printf(c.Str("symbol:%s\n"), symbol.CStr())
+
+		typeStr := cursor.ResultType().String()
+		defer typeStr.Dispose()
+		c.Printf(c.Str("Return Type: %s\n"), typeStr.CStr())
+		c.Printf(c.Str("Parameters(%d): ( "), cursor.NumArguments())
+
+		for i := 0; i < int(cursor.NumArguments()); i++ {
+			argCurSor := cursor.Argument(c.Uint(i))
+			argType := argCurSor.Type().String()
+			argName := argCurSor.String()
+			c.Printf(c.Str("%s %s"), argType.CStr(), argName.CStr())
+			if i < int(cursor.NumArguments())-1 {
+				c.Printf(c.Str(", "))
+			}
+
+			argType.Dispose()
+			argName.Dispose()
+		}
+
+		c.Printf(c.Str(" )\n"))
+		println("--------------------------------")
+	}
+}
+
+func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
+	if cursor.Kind == clang.CursorMacroDefinition {
+		printMarcoInfo(cursor)
+	} else if cursor.Kind == clang.CursorNamespace {
+		nameStr := cursor.String()
+		context.setNamespaceName(c.GoString(nameStr.CStr()))
+		clang.VisitChildren(cursor, visit, nil)
+		context.setNamespaceName("")
+	} else if cursor.Kind == clang.CursorClassDecl {
+		nameStr := cursor.String()
+		context.setClassName(c.GoString(nameStr.CStr()))
+		clang.VisitChildren(cursor, visit, nil)
+		context.setClassName("")
+	} else if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl {
+		printFuncInfo(cursor)
+	}
+
+	return clang.ChildVisit_Continue
+}
+
+func parse(filename *c.Char) {
+	index := clang.CreateIndex(0, 0)
+	args := make([]*c.Char, 3)
+	args[0] = c.Str("-x")
+	args[1] = c.Str("c++")
+	args[2] = c.Str("-std=c++11")
+	unit := index.ParseTranslationUnit(
+		filename,
+		unsafe.SliceData(args), 3,
+		nil, 0,
+		clang.DetailedPreprocessingRecord,
+	)
+
+	if unit == nil {
+		println("Unable to parse translation unit. Quitting.")
+		c.Exit(1)
+	}
+
+	context.setUnit(unit)
+	cursor := unit.Cursor()
+
+	clang.VisitChildren(cursor, visit, nil)
+	unit.Dispose()
+	index.Dispose()
+}
+
+func main() {
+	if c.Argc != 2 {
+		fmt.Fprintln(os.Stderr, "Usage: <C++ header file>\n")
+		return
+	} else {
+		sourceFile := *c.Advance(c.Argv, 1)
+		parse(sourceFile)
+	}
+}

c/clang/_wrap/cursor.cpp

@@ -1,29 +1,82 @@
-#include <stdio.h>
 #include <clang-c/Index.h>
+#include <stdio.h>
 
-typedef enum CXChildVisitResult(* wrap_CXCursorVisitor) (CXCursor *cursor, CXCursor *parent, CXClientData client_data);
+typedef enum CXChildVisitResult (*wrap_CXCursorVisitor)(CXCursor *cursor, CXCursor *parent, CXClientData client_data);
 
 typedef struct {
-    CXClientData         data;
+    CXClientData data;
     wrap_CXCursorVisitor visitor;
 } wrap_data;
 
 CXChildVisitResult wrap_visitor(CXCursor cursor, CXCursor parent, CXClientData data) {
-    wrap_data *d = (wrap_data*)(data);
+    wrap_data *d = (wrap_data *)(data);
-    return d->visitor(&cursor,&parent,d->data);
+    return d->visitor(&cursor, &parent, d->data);
 }
 
 extern "C" {
 
-CXString wrap_clang_getCursorSpelling(CXCursor *cur) {
+CXString wrap_clang_getCursorSpelling(CXCursor *cur) { return clang_getCursorSpelling(*cur); }
-    return clang_getCursorSpelling(*cur);
+
+CXString wrap_clang_Cursor_getMangling(CXCursor *cur) { return clang_Cursor_getMangling(*cur); }
+
+int wrap_clang_Cursor_getNumArguments(CXCursor *cur) { return clang_Cursor_getNumArguments(*cur); }
+
+void wrap_clang_Cursor_getArgument(CXCursor *C, unsigned i, CXCursor *argCur) {
+    *argCur = clang_Cursor_getArgument(*C, i);
 }
 
-unsigned wrap_clang_visitChildren(CXCursor *parent, 
+void wrap_clang_getTranslationUnitCursor(CXTranslationUnit uint, CXCursor *cur) {
-    wrap_CXCursorVisitor visitor,
+    *cur = clang_getTranslationUnitCursor(uint);
-    CXClientData client_data) {
+}
-    wrap_data data = {client_data,visitor};
+
-    return clang_visitChildren(*parent,wrap_visitor,CXClientData(&data));
+void wrap_clang_getCursorType(CXCursor *cur, CXType *typ) { *typ = clang_getCursorType(*cur); }
+
+void wrap_clang_getCursorResultType(CXCursor *cur, CXType *typ) { *typ = clang_getCursorResultType(*cur); }
+
+void wrap_clang_getResultType(CXType *typ, CXType *resultTyp) { *resultTyp = clang_getResultType(*typ); }
+
+int wrap_clang_getNumArgTypes(CXType *typ) { return clang_getNumArgTypes(*typ); }
+
+void wrap_clang_getArgType(CXType *typ, unsigned i, CXType *argTyp) { *argTyp = clang_getArgType(*typ, i); }
+
+long long wrap_clang_getEnumConstantDeclValue(CXCursor *cur) { return clang_getEnumConstantDeclValue(*cur); }
+
+void wrap_clang_getPointeeType(CXType *pointerTyp, CXType *pointeeTyp) {
+    *pointeeTyp = clang_getPointeeType(*pointerTyp);
+}
+
+void wrap_clang_getArrayElementType(CXType *arrayTyp, CXType *elemTyp) {
+    *elemTyp = clang_getArrayElementType(*arrayTyp);
+}
+
+void wrap_clang_getCanonicalType(CXType *typ, CXType *canonicalType) { *canonicalType = clang_getCanonicalType(*typ); }
+
+CXString wrap_clang_getTypeSpelling(CXType *typ) { return clang_getTypeSpelling(*typ); }
+
+CXString wrap_clang_getTokenSpelling(CXTranslationUnit unit, CXToken *token) {
+    return clang_getTokenSpelling(unit, *token);
+}
+
+void wrap_clang_getCursorLocation(CXCursor *cur, CXSourceLocation *loc) { *loc = clang_getCursorLocation(*cur); }
+
+void wrap_clang_getSpellingLocation(CXSourceLocation *loc, CXFile *file, unsigned *line, unsigned *column,
+                                    unsigned *offset) {
+    clang_getSpellingLocation(*loc, file, line, column, offset);
+}
+
+enum CX_CXXAccessSpecifier wrap_clang_getCXXAccessSpecifier(CXCursor *cursor) {
+    return clang_getCXXAccessSpecifier(*cursor);
+}
+
+void wrap_clang_getCursorExtent(CXCursor *cur, CXSourceRange *range) { *range = clang_getCursorExtent(*cur); }
+
+void wrap_clang_tokenize(CXTranslationUnit unit, CXSourceRange *Range, CXToken **Tokens, unsigned *NumTokens) {
+    clang_tokenize(unit, *Range, Tokens, NumTokens);
+}
+
+unsigned wrap_clang_visitChildren(CXCursor *parent, wrap_CXCursorVisitor visitor, CXClientData client_data) {
+    wrap_data data = {client_data, visitor};
+    return clang_visitChildren(*parent, wrap_visitor, CXClientData(&data));
 }
 
 } // extern "C"

c/libuv/README.md

@@ -0,0 +1,44 @@
+LLGo wrapper of libuv
+=====
+
+## How to install
+
+### on macOS (Homebrew)
+
+```sh
+brew install libuv
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+apt-get install -y libuv1-dev
+```
+
+### on Linux (CentOS/RHEL)
+
+```sh
+yum install -y libuv-devel
+```
+
+### on Linux (Arch Linux)
+
+```sh
+pacman -S libuv
+```
+
+## Demos
+
+The `_demo` directory contains our demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [async_fs](_demo/async_fs/async_fs.go): a simple async file read demo
+* [echo_server](_demo/echo_server/echo_server.go): a basic async tcp echo server
+
+### How to run demos
+
+To run the demos in directory `_demo`:
+
+```sh
+cd <demo-directory>  # eg. cd _demo/sqlitedemo
+llgo run .
+```

c/libuv/_demo/async/async.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/libuv"
+)
+
+func ensure(b bool, msg string) {
+	if !b {
+		panic(msg)
+	}
+}
+
+func main() {
+	loop := libuv.LoopNew()
+	defer loop.Close()
+
+	a := &libuv.Async{}
+	r := loop.Async(a, func(a *libuv.Async) {
+		println("async callback")
+		a.Close(nil) // or loop.Stop()
+	})
+	ensure(r == 0, "Async failed")
+
+	go func() {
+		println("begin async task")
+		c.Usleep(100 * 1000)
+		println("send async event")
+		ensure(a.Send() == 0, "Send failed")
+	}()
+
+	loop.Run(libuv.RUN_DEFAULT)
+	println("done")
+}
+
+/*Expected Output:
+begin async task
+send async event
+async callback
+done
+*/

c/libuv/_demo/async_fs/async_fs.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/libuv"
+	"github.com/goplus/llgo/c/os"
+)
+
+const BUFFER_SIZE = 1024
+
+var (
+	loop     *libuv.Loop
+	openReq  libuv.Fs
+	closeReq libuv.Fs
+
+	buffer [BUFFER_SIZE]c.Char
+	iov    libuv.Buf
+	file   libuv.File
+)
+
+func main() {
+	// Print the libuv version
+	c.Printf(c.Str("libuv version: %d\n"), libuv.Version())
+
+	// Initialize the loop
+	loop = libuv.DefaultLoop()
+
+	// Open the file
+	libuv.FsOpen(loop, &openReq, c.Str("example.txt"), os.O_RDONLY, 0, onOpen)
+
+	// Run the loop
+	result := loop.Run(libuv.RUN_DEFAULT)
+
+	if result != 0 {
+		c.Fprintf(c.Stderr, c.Str("Error in Run: %s\n"), libuv.Strerror(libuv.Errno(result)))
+	}
+
+	// Cleanup
+	defer cleanup()
+}
+
+func onOpen(req *libuv.Fs) {
+	// Check for errors
+	if req.GetResult() < 0 {
+		c.Fprintf(c.Stderr, c.Str("Error opening file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
+		loop.Close()
+		return
+	}
+
+	// Store the file descriptor
+	file = libuv.File(req.GetResult())
+
+	// Init buffer
+	iov = libuv.InitBuf((*c.Char)(unsafe.Pointer(&buffer[0])), c.Uint(unsafe.Sizeof(buffer)))
+
+	// Read the file
+	readFile()
+
+}
+
+func readFile() {
+	// Initialize the request every time
+	var readReq libuv.Fs
+
+	// Read the file
+	readRes := libuv.FsRead(loop, &readReq, file, &iov, 1, -1, onRead)
+	if readRes != 0 {
+		c.Printf(c.Str("Error in FsRead: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(readRes)), readRes)
+		readReq.ReqCleanup()
+		loop.Close()
+	}
+}
+
+func onRead(req *libuv.Fs) {
+	// Cleanup the request
+	defer req.ReqCleanup()
+	// Check for errors
+	if req.GetResult() < 0 {
+		c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
+	} else if req.GetResult() == 0 {
+		// Close the file
+		closeRes := libuv.FsClose(loop, &closeReq, libuv.File(openReq.GetResult()), onClose)
+		if closeRes != 0 {
+			c.Printf(c.Str("Error in FsClose: %s (code: %d)\n"), libuv.Strerror(libuv.Errno(closeRes)), closeRes)
+			loop.Close()
+			return
+		}
+	} else {
+		c.Printf(c.Str("Read %d bytes\n"), req.GetResult())
+		c.Printf(c.Str("Read content: %.*s\n"), req.GetResult(), (*c.Char)(unsafe.Pointer(&buffer[0])))
+		// Read the file again
+		readFile()
+	}
+}
+
+func onClose(req *libuv.Fs) {
+	// Check for errors
+	if req.GetResult() < 0 {
+		c.Fprintf(c.Stderr, c.Str("Error closing file: %s\n"), libuv.Strerror(libuv.Errno(req.GetResult())))
+	} else {
+		c.Printf(c.Str("\nFile closed successfully.\n"))
+	}
+}
+
+func cleanup() {
+	// Cleanup the requests
+	openReq.ReqCleanup()
+	closeReq.ReqCleanup()
+	// Close the loop
+	result := loop.Close()
+	if result != 0 {
+		c.Fprintf(c.Stderr, c.Str("Error in LoopClose: %s\n"), libuv.Strerror(libuv.Errno(result)))
+	}
+}

c/libuv/_demo/async_fs/example.txt

@@ -0,0 +1 @@
+123

c/libuv/_demo/echo_server/echo_server.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/libuv"
+	"github.com/goplus/llgo/c/net"
+)
+
+var DEFAULT_PORT c.Int = 8080
+var DEFAULT_BACKLOG c.Int = 128
+
+var (
+	Req *libuv.Write
+	Buf libuv.Buf
+)
+
+func main() {
+	// Initialize the default event loop
+	var loop = libuv.DefaultLoop()
+
+	// Initialize a TCP server
+	server := &libuv.Tcp{}
+	libuv.InitTcp(loop, server)
+
+	// Set up the address to bind the server to
+	var addr net.SockaddrIn
+	libuv.Ip4Addr(c.Str("0.0.0.0"), DEFAULT_PORT, &addr)
+	c.Printf(c.Str("Listening on %s:%d\n"), c.Str("0.0.0.0"), DEFAULT_PORT)
+
+	// Bind the server to the specified address and port
+	server.Bind((*net.SockAddr)(c.Pointer(&addr)), 0)
+	res := (*libuv.Stream)(server).Listen(DEFAULT_BACKLOG, OnNewConnection)
+	if res != 0 {
+		c.Fprintf(c.Stderr, c.Str("Listen error: %s\n"), libuv.Strerror(libuv.Errno(res)))
+		return
+	}
+
+	// Start listening for incoming connections
+	loop.Run(libuv.RUN_DEFAULT)
+}
+
+func FreeWriteReq() {
+	// Free the buffer base.
+	c.Free(c.Pointer(Buf.Base))
+}
+
+func AllocBuffer(handle *libuv.Handle, suggestedSize uintptr, buf *libuv.Buf) {
+	// Allocate memory for the buffer based on the suggested size.
+	buf.Base = (*c.Char)(c.Malloc(suggestedSize))
+	buf.Len = suggestedSize
+}
+
+func EchoWrite(req *libuv.Write, status c.Int) {
+	if status != 0 {
+		c.Fprintf(c.Stderr, c.Str("Write error: %s\n"), libuv.Strerror(libuv.Errno(status)))
+	}
+	FreeWriteReq()
+}
+
+func EchoRead(client *libuv.Stream, nread c.Long, buf *libuv.Buf) {
+	if nread > 0 {
+		// Initialize the buffer with the data read.
+		Buf = libuv.InitBuf(buf.Base, c.Uint(nread))
+		// Write the data back to the client.
+		Req = &libuv.Write{}
+		Req.Write(client, &Buf, 1, EchoWrite)
+		return
+	}
+	if nread < 0 {
+		// Handle read errors and EOF.
+		if (libuv.Errno)(nread) != libuv.EOF {
+			c.Fprintf(c.Stderr, c.Str("Read error: %s\n"), libuv.Strerror(libuv.Errno(nread)))
+		}
+		(*libuv.Handle)(c.Pointer(client)).Close(nil)
+	}
+	// Free the buffer if it's no longer needed.
+	if buf.Base != nil {
+		c.Free(c.Pointer(buf.Base))
+	}
+}
+
+func OnNewConnection(server *libuv.Stream, status c.Int) {
+	if status < 0 {
+		c.Fprintf(c.Stderr, c.Str("New connection error: %s\n"), libuv.Strerror(libuv.Errno(status)))
+		return
+	}
+
+	// Allocate memory for a new client.
+	client := &libuv.Tcp{}
+
+	if client == nil {
+		c.Fprintf(c.Stderr, c.Str("Failed to allocate memory for client\n"))
+		return
+	}
+
+	// Initialize the client TCP handle.
+	if libuv.InitTcp(libuv.DefaultLoop(), client) < 0 {
+		c.Fprintf(c.Stderr, c.Str("Failed to initialize client\n"))
+		c.Free(c.Pointer(client))
+		return
+	}
+
+	// Accept the new connection and start reading data.
+	if server.Accept((*libuv.Stream)(client)) == 0 {
+		(*libuv.Stream)(client).StartRead(AllocBuffer, EchoRead)
+	} else {
+		(*libuv.Handle)(c.Pointer(client)).Close(nil)
+	}
+}

c/libuv/_wrap/libuv.c

@@ -0,0 +1,5 @@
+#include <uv.h>
+
+int uv_tcp_get_io_watcher_fd (uv_tcp_t* handle) {
+  return handle->io_watcher.fd;
+}

c/libuv/async.go

@@ -0,0 +1,50 @@
+/*
+ * 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 libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// struct uv_async_t
+type Async struct {
+	Handle
+	// On macOS arm64, sizeof uv_async_t is 128 bytes.
+	// Handle is 92 bytes, so we need 36 bytes to fill the gap.
+	// Maybe reserve more for future use.
+	Unused [36]byte
+}
+
+// typedef void (*uv_async_cb)(uv_async_t* handle);
+// llgo:type C
+type AsyncCb func(*Async)
+
+// int uv_async_init(uv_loop_t*, uv_async_t* async, uv_async_cb async_cb);
+//
+// llgo:link (*Loop).Async C.uv_async_init
+func (loop *Loop) Async(a *Async, cb AsyncCb) c.Int {
+	return 0
+}
+
+// int uv_async_send(uv_async_t* async);
+//
+// llgo:link (*Async).Send C.uv_async_send
+func (a *Async) Send() c.Int {
+	return 0
+}

c/libuv/error.go

@@ -0,0 +1,118 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
+	"github.com/goplus/llgo/c/syscall"
+)
+
+const (
+	E2BIG           = Errno(syscall.E2BIG)
+	EACCES          = Errno(syscall.EACCES)
+	EADDRINUSE      = Errno(syscall.EADDRINUSE)
+	EADDRNOTAVAIL   = Errno(syscall.EADDRNOTAVAIL)
+	EAFNOSUPPORT    = Errno(syscall.EAFNOSUPPORT)
+	EAGAIN          = Errno(syscall.EAGAIN)
+	EALREADY        = Errno(syscall.EALREADY)
+	EBADF           = Errno(syscall.EBADF)
+	EBUSY           = Errno(syscall.EBUSY)
+	ECANCELED       = Errno(syscall.ECANCELED)
+	ECONNABORTED    = Errno(syscall.ECONNABORTED)
+	ECONNREFUSED    = Errno(syscall.ECONNREFUSED)
+	ECONNRESET      = Errno(syscall.ECONNRESET)
+	EDESTADDRREQ    = Errno(syscall.EDESTADDRREQ)
+	EEXIST          = Errno(syscall.EEXIST)
+	EFAULT          = Errno(syscall.EFAULT)
+	EFBIG           = Errno(syscall.EFBIG)
+	EHOSTUNREACH    = Errno(syscall.EHOSTUNREACH)
+	EINTR           = Errno(syscall.EINTR)
+	EINVAL          = Errno(syscall.EINVAL)
+	EIO             = Errno(syscall.EIO)
+	EISCONN         = Errno(syscall.EISCONN)
+	EISDIR          = Errno(syscall.EISDIR)
+	ELOOP           = Errno(syscall.ELOOP)
+	EMFILE          = Errno(syscall.EMFILE)
+	EMSGSIZE        = Errno(syscall.EMSGSIZE)
+	ENAMETOOLONG    = Errno(syscall.ENAMETOOLONG)
+	ENETDOWN        = Errno(syscall.ENETDOWN)
+	ENETUNREACH     = Errno(syscall.ENETUNREACH)
+	ENFILE          = Errno(syscall.ENFILE)
+	ENOBUFS         = Errno(syscall.ENOBUFS)
+	ENODEV          = Errno(syscall.ENODEV)
+	ENOENT          = Errno(syscall.ENOENT)
+	ENOMEM          = Errno(syscall.ENOMEM)
+	ENOPROTOOPT     = Errno(syscall.ENOPROTOOPT)
+	ENOSPC          = Errno(syscall.ENOSPC)
+	ENOSYS          = Errno(syscall.ENOSYS)
+	ENOTCONN        = Errno(syscall.ENOTCONN)
+	ENOTDIR         = Errno(syscall.ENOTDIR)
+	ENOTEMPTY       = Errno(syscall.ENOTEMPTY)
+	ENOTSOCK        = Errno(syscall.ENOTSOCK)
+	ENOTSUP         = Errno(syscall.ENOTSUP)
+	EOVERFLOW       = Errno(syscall.EOVERFLOW)
+	EPERM           = Errno(syscall.EPERM)
+	EPIPE           = Errno(syscall.EPIPE)
+	EPROTO          = Errno(syscall.EPROTO)
+	EPROTONOSUPPORT = Errno(syscall.EPROTONOSUPPORT)
+	EPROTOTYPE      = Errno(syscall.EPROTOTYPE)
+	ERANGE          = Errno(syscall.ERANGE)
+	EROFS           = Errno(syscall.EROFS)
+	ESHUTDOWN       = Errno(syscall.ESHUTDOWN)
+	ESPIPE          = Errno(syscall.ESPIPE)
+	ESRCH           = Errno(syscall.ESRCH)
+	ETIMEDOUT       = Errno(syscall.ETIMEDOUT)
+	ETXTBSY         = Errno(syscall.ETXTBSY)
+	EXDEV           = Errno(syscall.EXDEV)
+	ENXIO           = Errno(syscall.ENXIO)
+	EMLINK          = Errno(syscall.EMLINK)
+	EHOSTDOWN       = Errno(syscall.EHOSTDOWN)
+	ENOTTY          = Errno(syscall.ENOTTY)
+	//EFTYPE        = Errno(syscall.EFTYPE)
+	EILSEQ          = Errno(syscall.EILSEQ)
+	ESOCKTNOSUPPORT = Errno(syscall.ESOCKTNOSUPPORT)
+)
+
+const (
+	EAI_ADDRFAMILY = Errno(net.EAI_ADDRFAMILY)
+	EAI_AGAIN      = Errno(net.EAI_AGAIN)
+	EAI_BADFLAGS   = Errno(net.EAI_BADFLAGS)
+	EAI_BADHINTS   = Errno(net.EAI_BADHINTS)
+	EAI_FAIL       = Errno(net.EAI_FAIL)
+	EAI_FAMILY     = Errno(net.EAI_FAMILY)
+	EAI_MEMORY     = Errno(net.EAI_MEMORY)
+	EAI_NODATA     = Errno(net.EAI_NODATA)
+	EAI_NONAME     = Errno(net.EAI_NONAME)
+	EAI_OVERFLOW   = Errno(net.EAI_OVERFLOW)
+	EAI_PROTOCOL   = Errno(net.EAI_PROTOCOL)
+	EAI_SERVICE    = Errno(net.EAI_SERVICE)
+	EAI_SOCKTYPE   = Errno(net.EAI_SOCKTYPE)
+)
+
+const (
+	EAI_CANCELED Errno = -3003
+	ECHARSET     Errno = -4080
+	ENONET       Errno = -4056
+	UNKNOWN      Errno = -4094
+	EOF          Errno = -1
+	EREMOTEIO    Errno = -4030
+	ERRNO_MAX    Errno = EOF - 1
+)
+
+type Errno c.Int
+
+//go:linkname TranslateSysError C.uv_translate_sys_error
+func TranslateSysError(sysErrno c.Int) Errno
+
+//go:linkname Strerror C.uv_strerror
+func Strerror(err Errno) *c.Char
+
+//go:linkname StrerrorR C.uv_strerror_r
+func StrerrorR(err Errno, buf *c.Char, bufLen uintptr) *c.Char
+
+//go:linkname ErrName C.uv_err_name
+func ErrName(err Errno) *c.Char
+
+//go:linkname ErrNameR C.uv_err_name_r
+func ErrNameR(err Errno, buf *c.Char, bufLen uintptr) *c.Char

c/libuv/fs.go

@@ -0,0 +1,307 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	FS_UNKNOWN   FsType = -1
+	FS_CUSTOM    FsType = 0
+	FS_OPEN      FsType = 1
+	FS_CLOSE     FsType = 2
+	FS_READ      FsType = 3
+	FS_WRITE     FsType = 4
+	FS_SENDFILE  FsType = 5
+	FS_STAT      FsType = 6
+	FS_LSTAT     FsType = 7
+	FS_FSTAT     FsType = 8
+	FS_FTRUNCATE FsType = 9
+	FS_UTIME     FsType = 10
+	FS_FUTIME    FsType = 11
+	FS_ACCESS    FsType = 12
+	FS_CHMOD     FsType = 13
+	FS_FCHMOD    FsType = 14
+	FS_FSYNC     FsType = 15
+	FS_FDATASYNC FsType = 16
+	FS_UNLINK    FsType = 17
+	FS_RMDIR     FsType = 18
+	FS_MKDIR     FsType = 19
+	FS_MKDTEMP   FsType = 20
+	FS_RENAME    FsType = 21
+	FS_SCANDIR   FsType = 22
+	FS_LINK      FsType = 23
+	FS_SYMLINK   FsType = 24
+	FS_READLINK  FsType = 25
+	FS_CHOWN     FsType = 26
+	FS_FCHOWN    FsType = 27
+	FS_REALPATH  FsType = 28
+	FS_COPYFILE  FsType = 29
+	FS_LCHOWN    FsType = 30
+	FS_OPENDIR   FsType = 31
+	FS_READDIR   FsType = 32
+	FS_CLOSEDIR  FsType = 33
+	FS_STATFS    FsType = 34
+	FS_MKSTEMP   FsType = 35
+	FS_LUTIME    FsType = 36
+)
+
+const (
+	DirentUnknown DirentType = iota
+	DirentFile
+	DirentDir
+	DirentLink
+	DirentFifo
+	DirentSocket
+	DirentChar
+	DirentBlock
+)
+
+type FsType c.Int
+
+type DirentType c.Int
+
+type File c.Int
+
+// ----------------------------------------------
+
+/* Handle types. */
+
+type Fs struct {
+	Unused [440]byte
+}
+
+type FsEvent struct {
+	Unused [0]byte
+}
+
+type FsPoll struct {
+	Unused [0]byte
+}
+
+type Dirent struct {
+	Name *c.Char
+	Type DirentType
+}
+
+type Stat struct {
+	Unused [0]byte
+}
+
+// ----------------------------------------------
+
+/* Function type */
+
+// llgo:type C
+type FsCb func(req *Fs)
+
+// llgo:type C
+type FsEventCb func(handle *FsEvent, filename *c.Char, events c.Int, status c.Int)
+
+// llgo:type C
+type FsPollCb func(handle *FsPoll, status c.Int, events c.Int)
+
+// ----------------------------------------------
+
+/* Fs related function and method */
+
+// llgo:link (*Fs).GetType C.uv_fs_get_type
+func (req *Fs) GetType() FsType {
+	return 0
+}
+
+// llgo:link (*Fs).GetPath C.uv_fs_get_path
+func (req *Fs) GetPath() *c.Char {
+	return nil
+}
+
+// llgo:link (*Fs).GetResult C.uv_fs_get_result
+func (req *Fs) GetResult() c.Int {
+	return 0
+}
+
+// llgo:link (*Fs).GetPtr C.uv_fs_get_ptr
+func (req *Fs) GetPtr() c.Pointer {
+	return nil
+}
+
+// llgo:link (*Fs).GetSystemError C.uv_fs_get_system_error
+func (req *Fs) GetSystemError() c.Int {
+	return 0
+}
+
+// llgo:link (*Fs).GetStatBuf C.uv_fs_get_statbuf
+func (req *Fs) GetStatBuf() *Stat {
+	return nil
+}
+
+// llgo:link (*Fs).ReqCleanup C.uv_fs_req_cleanup
+func (req *Fs) ReqCleanup() {
+	// No return value needed for this method
+}
+
+//go:linkname FsOpen C.uv_fs_open
+func FsOpen(loop *Loop, req *Fs, path *c.Char, flags c.Int, mode c.Int, cb FsCb) c.Int
+
+//go:linkname FsClose C.uv_fs_close
+func FsClose(loop *Loop, req *Fs, file File, cb FsCb) c.Int
+
+//go:linkname FsRead C.uv_fs_read
+func FsRead(loop *Loop, req *Fs, file File, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
+
+//go:linkname FsWrite C.uv_fs_write
+func FsWrite(loop *Loop, req *Fs, file File, bufs *Buf, nbufs c.Uint, offset c.LongLong, cb FsCb) c.Int
+
+//go:linkname FsUnlink C.uv_fs_unlink
+func FsUnlink(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsMkdir C.uv_fs_mkdir
+func FsMkdir(loop *Loop, req *Fs, path *c.Char, mode c.Int, cb FsCb) c.Int
+
+//go:linkname FsMkdtemp C.uv_fs_mkdtemp
+func FsMkdtemp(loop *Loop, req *Fs, tpl *c.Char, cb FsCb) c.Int
+
+//go:linkname FsMkStemp C.uv_fs_mkstemp
+func FsMkStemp(loop *Loop, req *Fs, tpl *c.Char, cb FsCb) c.Int
+
+//go:linkname FsRmdir C.uv_fs_rmdir
+func FsRmdir(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsStat C.uv_fs_stat
+func FsStat(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsFstat C.uv_fs_fstat
+func FsFstat(loop *Loop, req *Fs, file File, cb FsCb) c.Int
+
+//go:linkname FsRename C.uv_fs_rename
+func FsRename(loop *Loop, req *Fs, path *c.Char, newPath *c.Char, cb FsCb) c.Int
+
+//go:linkname FsFsync C.uv_fs_fsync
+func FsFsync(loop *Loop, req *Fs, file File, cb FsCb) c.Int
+
+//go:linkname FsFdatasync C.uv_fs_fdatasync
+func FsFdatasync(loop *Loop, req *Fs, file File, cb FsCb) c.Int
+
+//go:linkname FsFtruncate C.uv_fs_ftruncate
+func FsFtruncate(loop *Loop, req *Fs, file File, offset c.LongLong, cb FsCb) c.Int
+
+//go:linkname FsSendfile C.uv_fs_sendfile
+func FsSendfile(loop *Loop, req *Fs, outFd c.Int, inFd c.Int, inOffset c.LongLong, length c.Int, cb FsCb) c.Int
+
+//go:linkname FsAccess C.uv_fs_access
+func FsAccess(loop *Loop, req *Fs, path *c.Char, flags c.Int, cb FsCb) c.Int
+
+//go:linkname FsChmod C.uv_fs_chmod
+func FsChmod(loop *Loop, req *Fs, path *c.Char, mode c.Int, cb FsCb) c.Int
+
+//go:linkname FsFchmod C.uv_fs_fchmod
+func FsFchmod(loop *Loop, req *Fs, file File, mode c.Int, cb FsCb) c.Int
+
+//go:linkname FsUtime C.uv_fs_utime
+func FsUtime(loop *Loop, req *Fs, path *c.Char, atime c.Int, mtime c.Int, cb FsCb) c.Int
+
+//go:linkname FsFutime C.uv_fs_futime
+func FsFutime(loop *Loop, req *Fs, file File, atime c.Int, mtime c.Int, cb FsCb) c.Int
+
+//go:linkname FsLutime C.uv_fs_lutime
+func FsLutime(loop *Loop, req *Fs, path *c.Char, atime c.Int, mtime c.Int, cb FsCb) c.Int
+
+//go:linkname FsLink C.uv_fs_link
+func FsLink(loop *Loop, req *Fs, path *c.Char, newPath *c.Char, cb FsCb) c.Int
+
+//go:linkname FsSymlink C.uv_fs_symlink
+func FsSymlink(loop *Loop, req *Fs, path *c.Char, newPath *c.Char, flags c.Int, cb FsCb) c.Int
+
+//go:linkname FsReadlink C.uv_fs_read
+func FsReadlink(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsRealpath C.uv_fs_realpath
+func FsRealpath(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsCopyfile C.uv_fs_copyfile
+func FsCopyfile(loop *Loop, req *Fs, path *c.Char, newPath *c.Char, flags c.Int, cb FsCb) c.Int
+
+//go:linkname FsScandir C.uv_fs_scandir
+func FsScandir(loop *Loop, req *Fs, path *c.Char, flags c.Int, cb FsCb) c.Int
+
+//go:linkname FsScandirNext C.uv_fs_scandir_next
+func FsScandirNext(req *Fs, ent *Dirent) c.Int
+
+//go:linkname FsOpenDir C.uv_fs_opendir
+func FsOpenDir(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsReaddir C.uv_fs_readdir
+func FsReaddir(loop *Loop, req *Fs, dir c.Int, cb FsCb) c.Int
+
+//go:linkname FsCloseDir C.uv_fs_closedir
+func FsCloseDir(loop *Loop, req *Fs) c.Int
+
+//go:linkname FsStatfs C.uv_fs_statfs
+func FsStatfs(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+//go:linkname FsChown C.uv_fs_chown
+func FsChown(loop *Loop, req *Fs, path *c.Char, uid c.Int, gid c.Int, cb FsCb) c.Int
+
+//go:linkname FsFchown C.uv_fs_fchown
+func FsFchown(loop *Loop, req *Fs, file File, uid c.Int, gid c.Int, cb FsCb) c.Int
+
+//go:linkname FsLchown C.uv_fs_lchown
+func FsLchown(loop *Loop, req *Fs, path *c.Char, uid c.Int, gid c.Int, cb FsCb) c.Int
+
+//go:linkname FsLstat C.uv_fs_lstat
+func FsLstat(loop *Loop, req *Fs, path *c.Char, cb FsCb) c.Int
+
+// ----------------------------------------------
+
+/* FsEvent related function and method */
+
+//go:linkname FsEventInit C.uv_fs_event_init
+func FsEventInit(loop *Loop, handle *FsEvent) c.Int
+
+// llgo:link (*FsEvent).Start C.uv_fs_event_start
+func (handle *FsEvent) Start(cb FsEventCb, path *c.Char, flags c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*FsEvent).Stop C.uv_fs_event_stop
+func (handle *FsEvent) Stop() c.Int {
+	return 0
+}
+
+// llgo:link (*FsEvent).Close C.uv_fs_event_close
+func (handle *FsEvent) Close() c.Int {
+	return 0
+}
+
+// llgo:link (*FsEvent).Getpath C.uv_fs_event_getpath
+func (handle *FsEvent) Getpath() *c.Char {
+	return nil
+}
+
+// ----------------------------------------------
+
+/* FsPoll related function and method */
+
+//go:linkname FsPollInit C.uv_fs_poll_init
+func FsPollInit(loop *Loop, handle *FsPoll) c.Int
+
+// llgo:link (*FsPoll).Start C.uv_fs_poll_start
+func (handle *FsPoll) Start(cb FsPollCb, path *c.Char, interval uint) c.Int {
+	return 0
+}
+
+// llgo:link (*FsPoll).Stop C.uv_fs_poll_stop
+func (handle *FsPoll) Stop() c.Int {
+	return 0
+}
+
+// llgo:link (*FsPoll).Close C.uv_fs_poll_close
+func (handle *FsPoll) Close() c.Int {
+	return 0
+}
+
+// llgo:link (*FsPoll).GetPath C.uv_fs_poll_getpath
+func (handle *FsPoll) GetPath() *c.Char {
+	return nil
+}

c/libuv/libuv.go

@@ -0,0 +1,265 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
+)
+
+const (
+	LLGoPackage = "link: $(pkg-config --libs libuv); -luv"
+	LLGoFiles   = "$(pkg-config --cflags libuv): _wrap/libuv.c"
+)
+
+// ----------------------------------------------
+const (
+	RUN_DEFAULT RunMode = iota
+	RUN_ONCE
+	RUN_NOWAIT
+)
+
+const (
+	LOOP_BLOCK_SIGNAL LoopOption = iota
+	METRICS_IDLE_TIME
+)
+
+const (
+	UV_LEAVE_GROUP Membership = iota
+	UV_JOIN_GROUP
+)
+
+const (
+	UNKNOWN_HANDLE HandleType = iota
+	ASYNC
+	CHECK
+	FS_EVENT
+	FS_POLL
+	HANDLE
+	IDLE
+	NAMED_PIPE
+	POLL
+	PREPARE
+	PROCESS
+	STREAM
+	TCP
+	TIMER
+	TTY
+	UDP
+	SIGNAL
+	FILE
+	HANDLE_TYPE_MAX
+)
+
+const (
+	UNKNOWN_REQ ReqType = iota
+	REQ
+	CONNECT
+	WRITE
+	SHUTDOWN
+	UDP_SEND
+	FS
+	WORK
+	GETADDRINFO
+	GETNAMEINFO
+	RANDOM
+	REQ_TYPE_PRIVATE
+	REQ_TYPE_MAX
+)
+
+const (
+	READABLE PollEvent = 1 << iota
+	WRITABLE
+	DISCONNECT
+	PRIPRIORITIZED
+)
+
+type RunMode c.Int
+
+type LoopOption c.Int
+
+type Membership c.Int
+
+type HandleType c.Int
+
+type ReqType c.Int
+
+type OsSock c.Int
+
+type OsFd c.Int
+
+type PollEvent c.Int
+
+// ----------------------------------------------
+
+/* Handle types. */
+
+type Loop struct {
+	Unused [0]byte
+}
+
+type Poll struct {
+	Unused [0]byte
+}
+
+/* Request types. */
+
+type Buf struct {
+	Base *c.Char
+	Len  uintptr
+} // ----------------------------------------------
+
+/* Function type */
+
+// llgo:type C
+type MallocFunc func(size uintptr) c.Pointer
+
+// llgo:type C
+type ReallocFunc func(ptr c.Pointer, size uintptr) c.Pointer
+
+// llgo:type C
+type CallocFunc func(count uintptr, size uintptr) c.Pointer
+
+// llgo:type C
+type FreeFunc func(ptr c.Pointer)
+
+// llgo:type C
+type AllocCb func(handle *Handle, suggestedSize uintptr, buf *Buf)
+
+// llgo:type C
+type GetaddrinfoCb func(req *GetAddrInfo, status c.Int, res *net.AddrInfo)
+
+// llgo:type C
+type GetnameinfoCb func(req *GetNameInfo, status c.Int, hostname *c.Char, service *c.Char)
+
+// llgo:type C
+type WalkCb func(handle *Handle, arg c.Pointer)
+
+// llgo:type C
+type PollCb func(handle *Poll, status c.Int, events c.Int)
+
+// ----------------------------------------------
+
+//go:linkname Version C.uv_version
+func Version() c.Uint
+
+//go:linkname VersionString C.uv_version_string
+func VersionString() *c.Char
+
+//go:linkname LibraryShutdown C.uv_library_shutdown
+func LibraryShutdown()
+
+//go:linkname ReplaceAllocator C.uv_replace_allocator
+func ReplaceAllocator(mallocFunc MallocFunc, reallocFunc ReallocFunc, callocFunc CallocFunc, freeFunc FreeFunc) c.Int
+
+// ----------------------------------------------
+
+/* Loop related functions and method. */
+
+//go:linkname DefaultLoop C.uv_default_loop
+func DefaultLoop() *Loop
+
+//go:linkname LoopSize C.uv_loop_size
+func LoopSize() uintptr
+
+// llgo:link (*Loop).Run C.uv_run
+func (loop *Loop) Run(mode RunMode) c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).Alive C.uv_loop_alive
+func (loop *Loop) Alive() c.Int {
+	return 0
+}
+
+// void uv_stop(uv_loop_t *loop)
+//
+// llgo:link (*Loop).Stop C.uv_stop
+func (loop *Loop) Stop() {}
+
+// llgo:link (*Loop).Close C.uv_loop_close
+func (loop *Loop) Close() c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).Configure C.uv_loop_configure
+func (loop *Loop) Configure(option LoopOption, arg c.Int) c.Int {
+	return 0
+}
+
+// llgo:link LoopDefault C.uv_default_loop
+func LoopDefault() *Loop {
+	return nil
+}
+
+// llgo:link (*Loop).Delete C.uv_loop_delete
+func (loop *Loop) Delete() c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).Fork C.uv_loop_fork
+func (loop *Loop) Fork() c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).Init C.uv_loop_init
+func (loop *Loop) Init() c.Int {
+	return 0
+}
+
+// llgo:link LoopNew C.uv_loop_new
+func LoopNew() *Loop {
+	return nil
+}
+
+// llgo:link (*Loop).Now C.uv_now
+func (loop *Loop) Now() c.UlongLong {
+	return 0
+}
+
+// llgo:link (*Loop).UpdateTime C.uv_update_time
+func (loop *Loop) UpdateTime() {
+	// No return value needed for this method
+}
+
+// llgo:link (*Loop).BackendFd C.uv_backend_fd
+func (loop *Loop) BackendFd() c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).BackendTimeout C.uv_backend_timeout
+func (loop *Loop) BackendTimeout() c.Int {
+	return 0
+}
+
+// llgo:link (*Loop).Walk C.uv_walk
+func (loop *Loop) Walk(walkCb WalkCb, arg c.Pointer) {
+	// No return value needed for this method
+}
+
+// ----------------------------------------------
+
+/* Buf related functions and method. */
+
+//go:linkname InitBuf C.uv_buf_init
+func InitBuf(base *c.Char, len c.Uint) Buf
+
+// ----------------------------------------------
+
+/* Poll related function and method */
+
+//go:linkname PollInit C.uv_poll_init
+func PollInit(loop *Loop, handle *Poll, fd OsFd) c.Int
+
+//go:linkname PollInitSocket C.uv_poll_init_socket
+func PollInitSocket(loop *Loop, handle *Poll, socket c.Int) c.Int
+
+// llgo:link (*Poll).Start C.uv_poll_start
+func (handle *Poll) Start(events c.Int, cb PollCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Poll).Stop C.uv_poll_stop
+func (handle *Poll) Stop() c.Int {
+	return 0
+}

c/libuv/net.go

@@ -0,0 +1,532 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
+)
+
+const (
+	/* Used with uv_tcp_bind, when an IPv6 address is used. */
+	TCP_IPV6ONLY TcpFlags = 1
+)
+
+/*
+ * UDP support.
+ */
+const (
+	/* Disables dual stack mode. */
+	UDP_IPV6ONLY UdpFlags = 1
+	/*
+	 * Indicates message was truncated because read buffer was too small. The
+	 * remainder was discarded by the OS. Used in uv_udp_recv_cb.
+	 */
+	UDP_PARTIAL UdpFlags = 2
+	/*
+	 * Indicates if SO_REUSEADDR will be set when binding the handle.
+	 * This sets the SO_REUSEPORT socket flag on the BSDs and OS X. On other
+	 * Unix platforms, it sets the SO_REUSEADDR flag.  What that means is that
+	 * multiple threads or processes can bind to the same address without error
+	 * (provided they all set the flag) but only the last one to bind will receive
+	 * any traffic, in effect "stealing" the port from the previous listener.
+	 */
+	UDP_REUSEADDR UdpFlags = 4
+	/*
+	 * Indicates that the message was received by recvmmsg, so the buffer provided
+	 * must not be freed by the recv_cb callback.
+	 */
+	UDP_MMSG_CHUNK UdpFlags = 8
+	/*
+	 * Indicates that the buffer provided has been fully utilized by recvmmsg and
+	 * that it should now be freed by the recv_cb callback. When this flag is set
+	 * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL.
+	 */
+	UDP_MMSG_FREE UdpFlags = 16
+	/*
+	 * Indicates if IP_RECVERR/IPV6_RECVERR will be set when binding the handle.
+	 * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on
+	 * Linux. This stops the Linux kernel from suppressing some ICMP error
+	 * messages and enables full ICMP error reporting for faster failover.
+	 * This flag is no-op on platforms other than Linux.
+	 */
+	UDP_LINUX_RECVERR UdpFlags = 32
+	/*
+	 * Indicates that recvmmsg should be used, if available.
+	 */
+	UDP_RECVMMSG UdpFlags = 256
+)
+
+type TcpFlags c.Int
+
+type UdpFlags c.Int
+
+// ----------------------------------------------
+
+/* Handle types. */
+
+// TODO(spongehah): Handle
+type Handle struct {
+	Data   c.Pointer
+	Unused [88]byte
+}
+
+// TODO(spongehah): Stream
+type Stream struct {
+	Data   c.Pointer
+	Unused [256]byte
+}
+
+// TODO(spongehah): Tcp
+type Tcp struct {
+	Data   c.Pointer
+	Unused [256]byte
+}
+
+type Udp struct {
+	Unused [0]byte
+}
+
+/* Request types. */
+
+type Req struct {
+	Unused [0]byte
+}
+
+type UdpSend struct {
+	Unused [0]byte
+}
+
+// TODO(spongehah): Write
+type Write struct {
+	Data   c.Pointer
+	Unused [184]byte
+}
+
+// TODO(spongehah): Connect
+type Connect struct {
+	Data   c.Pointer
+	Unused [88]byte
+}
+
+type GetAddrInfo struct {
+	Unused [0]byte
+}
+
+type GetNameInfo struct {
+	Unused [0]byte
+}
+
+type Shutdown struct {
+	Unused [0]byte
+}
+
+// ----------------------------------------------
+
+/* Function type */
+
+// llgo:type C
+type CloseCb func(handle *Handle)
+
+// llgo:type C
+type ConnectCb func(req *Connect, status c.Int)
+
+// llgo:type C
+type UdpSendCb func(req *UdpSend, status c.Int)
+
+// llgo:type C
+type UdpRecvCb func(handle *Udp, nread c.Long, buf *Buf, addr *net.SockAddr, flags c.Uint)
+
+// llgo:type C
+type ReadCb func(stream *Stream, nread c.Long, buf *Buf)
+
+// llgo:type C
+type WriteCb func(req *Write, status c.Int)
+
+// llgo:type C
+type ConnectionCb func(server *Stream, status c.Int)
+
+// llgo:type C
+type ShutdownCb func(req *Shutdown, status c.Int)
+
+// ----------------------------------------------
+
+/* Handle related function and method */
+
+//go:linkname HandleSize C.uv_handle_size
+func HandleSize(handleType HandleType) uintptr
+
+//go:linkname HandleTypeName C.uv_handle_type_name
+func HandleTypeName(handleType HandleType) *c.Char
+
+// llgo:link (*Handle).Ref C.uv_ref
+func (handle *Handle) Ref() {}
+
+// llgo:link (*Handle).Unref C.uv_unref
+func (handle *Handle) Unref() {}
+
+// llgo:link (*Handle).HasRef C.uv_has_ref
+func (handle *Handle) HasRef() c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).GetType C.uv_handle_get_type
+func (handle *Handle) GetType() HandleType {
+	return 0
+}
+
+// llgo:link (*Handle).GetData C.uv_handle_get_data
+func (handle *Handle) GetData() c.Pointer {
+	return nil
+}
+
+// llgo:link (*Handle).GetLoop C.uv_handle_get_loop
+func (handle *Handle) GetLoop() *Loop {
+	return nil
+}
+
+// llgo:link (*Handle).SetData C.uv_handle_set_data
+func (handle *Handle) SetData(data c.Pointer) {}
+
+// llgo:link (*Handle).IsActive C.uv_is_active
+func (handle *Handle) IsActive() c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).Close C.uv_close
+func (handle *Handle) Close(closeCb CloseCb) {}
+
+// llgo:link (*Handle).SendBufferSize C.uv_send_buffer_size
+func (handle *Handle) SendBufferSize(value *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).RecvBufferSize C.uv_recv_buffer_size
+func (handle *Handle) RecvBufferSize(value *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).Fileno C.uv_fileno
+func (handle *Handle) Fileno(fd *OsFd) c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).IsClosing C.uv_is_closing
+func (handle *Handle) IsClosing() c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).IsReadable C.uv_is_readable
+func (handle *Handle) IsReadable() c.Int {
+	return 0
+}
+
+// llgo:link (*Handle).IsWritable C.uv_is_writable
+func (handle *Handle) IsWritable() c.Int {
+	return 0
+}
+
+//go:linkname Pipe C.uv_pipe
+func Pipe(fds [2]File, readFlags c.Int, writeFlags c.Int) c.Int {
+	return 0
+}
+
+//go:linkname Socketpair C.uv_socketpair
+func Socketpair(_type c.Int, protocol c.Int, socketVector [2]OsSock, flag0 c.Int, flag1 c.Int) c.Int {
+	return 0
+}
+
+// ----------------------------------------------
+
+/* Req related function and method */
+
+//go:linkname ReqSize C.uv_req_size
+func ReqSize(reqType ReqType) uintptr
+
+//go:linkname TypeName C.uv_req_type_name
+func TypeName(reqType ReqType) *c.Char
+
+// llgo:link (*Req).GetData C.uv_req_get_data
+func (req *Req) GetData() c.Pointer {
+	return nil
+}
+
+// llgo:link (*Req).SetData C.uv_req_set_data
+func (req *Req) SetData(data c.Pointer) {}
+
+// llgo:link (*Req).GetType C.uv_req_get_type
+func (req *Req) GetType() ReqType {
+	return 0
+}
+
+// ----------------------------------------------
+
+/* Stream related function and method */
+
+// llgo:link (*Stream).GetWriteQueueSize C.uv_stream_get_write_queue_size
+func (stream *Stream) GetWriteQueueSize() uintptr {
+	return 0
+}
+
+// llgo:link (*Stream).Listen C.uv_listen
+func (stream *Stream) Listen(backlog c.Int, connectionCb ConnectionCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).Accept C.uv_accept
+func (server *Stream) Accept(client *Stream) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).StartRead C.uv_read_start
+func (stream *Stream) StartRead(allocCb AllocCb, readCb ReadCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).StopRead C.uv_read_stop
+func (stream *Stream) StopRead() c.Int {
+	return 0
+}
+
+// llgo:link (*Write).Write C.uv_write
+func (req *Write) Write(stream *Stream, bufs *Buf, nbufs c.Uint, writeCb WriteCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Write).Write2 C.uv_write2
+func (req *Write) Write2(stream *Stream, bufs *Buf, nbufs c.Uint, sendStream *Stream, writeCb WriteCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).TryWrite C.uv_try_write
+func (stream *Stream) TryWrite(bufs *Buf, nbufs c.Uint) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).TryWrite2 C.uv_try_write2
+func (stream *Stream) TryWrite2(bufs *Buf, nbufs c.Uint, sendStream *Stream) c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).IsReadable C.uv_is_readable
+func (stream *Stream) IsReadable() c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).IsWritable C.uv_is_writable
+func (stream *Stream) IsWritable() c.Int {
+	return 0
+}
+
+// llgo:link (*Stream).SetBlocking C.uv_stream_set_blocking
+func (stream *Stream) SetBlocking(blocking c.Int) c.Int {
+	return 0
+}
+
+//go:linkname StreamShutdown C.uv_shutdown
+func StreamShutdown(shutdown *Shutdown, stream *Stream, shutdownCb ShutdownCb) c.Int {
+	return 0
+}
+
+// ----------------------------------------------
+
+/* Tcp related function and method */
+
+//go:linkname InitTcp C.uv_tcp_init
+func InitTcp(loop *Loop, tcp *Tcp) c.Int
+
+//go:linkname InitTcpEx C.uv_tcp_init_ex
+func InitTcpEx(loop *Loop, tcp *Tcp, flags c.Uint) c.Int
+
+// llgo:link (*Tcp).Open C.uv_tcp_open
+func (tcp *Tcp) Open(sock OsSock) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).Nodelay C.uv_tcp_nodelay
+func (tcp *Tcp) Nodelay(enable c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).KeepAlive C.uv_tcp_keepalive
+func (tcp *Tcp) KeepAlive(enable c.Int, delay c.Uint) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).SimultaneousAccepts C.uv_tcp_simultaneous_accepts
+func (tcp *Tcp) SimultaneousAccepts(enable c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).Bind C.uv_tcp_bind
+func (tcp *Tcp) Bind(addr *net.SockAddr, flags c.Uint) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).Getsockname C.uv_tcp_getsockname
+func (tcp *Tcp) Getsockname(name *net.SockAddr, nameLen *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).Getpeername C.uv_tcp_getpeername
+func (tcp *Tcp) Getpeername(name *net.SockAddr, nameLen *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).CloseReset C.uv_tcp_close_reset
+func (tcp *Tcp) CloseReset(closeCb CloseCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Tcp).GetIoWatcherFd C.uv_tcp_get_io_watcher_fd
+func (tcp *Tcp) GetIoWatcherFd() c.Int {
+	return 0
+}
+
+//go:linkname TcpConnect C.uv_tcp_connect
+func TcpConnect(req *Connect, tcp *Tcp, addr *net.SockAddr, connectCb ConnectCb) c.Int
+
+// ----------------------------------------------
+
+/* Udp related function and method */
+
+//go:linkname InitUdp C.uv_udp_init
+func InitUdp(loop *Loop, udp *Udp) c.Int
+
+//go:linkname InitUdpEx C.uv_udp_init_ex
+func InitUdpEx(loop *Loop, udp *Udp, flags c.Uint) c.Int
+
+// llgo:link (*Udp).Open C.uv_udp_open
+func (udp *Udp) Open(sock OsSock) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).Bind C.uv_udp_bind
+func (udp *Udp) Bind(addr *net.SockAddr, flags c.Uint) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).Connect C.uv_udp_connect
+func (udp *Udp) Connect(addr *net.SockAddr) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).Getpeername C.uv_udp_getpeername
+func (udp *Udp) Getpeername(name *net.SockAddr, nameLen *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).Getsockname C.uv_udp_getsockname
+func (udp *Udp) Getsockname(name *net.SockAddr, nameLen *c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetMembership C.uv_udp_set_membership
+func (udp *Udp) SetMembership(multicastAddr *c.Char, interfaceAddr *c.Char, membership Membership) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SourceMembership C.uv_udp_set_source_membership
+func (udp *Udp) SourceMembership(multicastAddr *c.Char, interfaceAddr *c.Char, sourceAddr *c.Char, membership Membership) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetMulticastLoop C.uv_udp_set_multicast_loop
+func (udp *Udp) SetMulticastLoop(on c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetMulticastTTL C.uv_udp_set_multicast_ttl
+func (udp *Udp) SetMulticastTTL(ttl c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetMulticastInterface C.uv_udp_set_multicast_interface
+func (udp *Udp) SetMulticastInterface(interfaceAddr *c.Char) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetBroadcast C.uv_udp_set_broadcast
+func (udp *Udp) SetBroadcast(on c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).SetTTL C.uv_udp_set_ttl
+func (udp *Udp) SetTTL(ttl c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).TrySend C.uv_udp_try_send
+func (udp *Udp) TrySend(bufs *Buf, nbufs c.Uint, addr *net.SockAddr) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).StartRecv C.uv_udp_recv_start
+func (udp *Udp) StartRecv(allocCb AllocCb, recvCb UdpRecvCb) c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).UsingRecvmmsg C.uv_udp_using_recvmmsg
+func (udp *Udp) UsingRecvmmsg() c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).StopRecv C.uv_udp_recv_stop
+func (udp *Udp) StopRecv() c.Int {
+	return 0
+}
+
+// llgo:link (*Udp).GetSendQueueSize C.uv_udp_get_send_queue_size
+func (udp *Udp) GetSendQueueSize() uintptr {
+	return 0
+}
+
+// llgo:link (*Udp).GetSendQueueCount C.uv_udp_get_send_queue_count
+func (udp *Udp) GetSendQueueCount() uintptr {
+	return 0
+}
+
+//go:linkname Send C.uv_udp_send
+func Send(req *UdpSend, udp *Udp, bufs *Buf, nbufs c.Uint, addr *net.SockAddr, sendCb UdpSendCb) c.Int
+
+// ----------------------------------------------
+
+/* DNS related function and method */
+
+//go:linkname Ip4Addr C.uv_ip4_addr
+func Ip4Addr(ip *c.Char, port c.Int, addr *net.SockaddrIn) c.Int
+
+//go:linkname Ip6Addr C.uv_ip6_addr
+func Ip6Addr(ip *c.Char, port c.Int, addr *net.SockaddrIn6) c.Int
+
+//go:linkname Ip4Name C.uv_ip4_name
+func Ip4Name(src *net.SockaddrIn, dst *c.Char, size uintptr) c.Int
+
+//go:linkname Ip6Name C.uv_ip6_name
+func Ip6Name(src *net.SockaddrIn6, dst *c.Char, size uintptr) c.Int
+
+//go:linkname IpName C.uv_ip_name
+func IpName(src *net.SockAddr, dst *c.Char, size uintptr) c.Int
+
+//go:linkname InetNtop C.uv_inet_ntop
+func InetNtop(af c.Int, src c.Pointer, dst *c.Char, size uintptr) c.Int
+
+//go:linkname InetPton C.uv_inet_pton
+func InetPton(af c.Int, src *c.Char, dst c.Pointer) c.Int
+
+// ----------------------------------------------
+
+/* Getaddrinfo related function and method */
+
+//go:linkname Getaddrinfo C.uv_getaddrinfo
+func Getaddrinfo(loop *Loop, req *GetAddrInfo, getaddrinfoCb GetaddrinfoCb, node *c.Char, service *c.Char, hints *net.AddrInfo) c.Int
+
+//go:linkname Freeaddrinfo C.uv_freeaddrinfo
+func Freeaddrinfo(addrInfo *net.AddrInfo)
+
+// ----------------------------------------------
+
+/* Getnameinfo related function and method */
+
+//go:linkname Getnameinfo C.uv_getnameinfo
+func Getnameinfo(loop *Loop, req *GetNameInfo, getnameinfoCb GetnameinfoCb, addr *net.SockAddr, flags c.Int) c.Int

c/libuv/signal.go

@@ -0,0 +1,42 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+/* Handle types. */
+
+type Signal struct {
+	Unused [0]byte
+}
+
+// ----------------------------------------------
+
+/* Function type */
+
+// llgo:type C
+type SignalCb func(handle *Signal, sigNum c.Int)
+
+// ----------------------------------------------
+
+/* Signal related functions and method. */
+
+//go:linkname SignalInit C.uv_signal_init
+func SignalInit(loop *Loop, handle *Signal) c.Int
+
+// llgo:link (*Signal).Start C.uv_signal_start
+func (handle *Signal) Start(cb SignalCb, signum c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Signal).StartOneshot C.uv_signal_start_oneshot
+func (handle *Signal) StartOneshot(cb SignalCb, signum c.Int) c.Int {
+	return 0
+}
+
+// llgo:link (*Signal).Stop C.uv_signal_stop
+func (handle *Signal) Stop() c.Int {
+	return 0
+}

c/libuv/timer.go

@@ -0,0 +1,56 @@
+package libuv
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// ----------------------------------------------
+
+/* Handle types. */
+
+// TODO(spongehah): Timer
+type Timer struct {
+	Unused [0]byte
+}
+
+// ----------------------------------------------
+
+// llgo:type Cgit
+type TimerCb func(timer *Timer)
+
+// ----------------------------------------------
+
+/* Timer related function and method */
+
+//go:linkname InitTimer C.uv_timer_init
+func InitTimer(loop *Loop, timer *Timer) c.Int
+
+// llgo:link (*Timer).Start C.uv_timer_start
+func (timer *Timer) Start(cb TimerCb, timeout uint64, repeat uint64) c.Int {
+	return 0
+}
+
+// llgo:link (*Timer).Stop C.uv_timer_stop
+func (timer *Timer) Stop() c.Int {
+	return 0
+}
+
+// llgo:link (*Timer).Again C.uv_timer_again
+func (timer *Timer) Again() c.Int {
+	return 0
+}
+
+// llgo:link (*Timer).SetRepeat C.uv_timer_set_repeat
+func (timer *Timer) SetRepeat(repeat uint64) {}
+
+// llgo:link (*Timer).GetRepeat C.uv_timer_get_repeat
+func (timer *Timer) GetRepeat() uint64 {
+	return 0
+}
+
+// llgo:link (*Timer).GetDueIn C.uv_timer_get_due_in
+func (timer *Timer) GetDueIn() uint64 {
+	return 0
+}

c/lua/_demo/coroutine-cfunc/coroutine.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func coroutineFunc(L *lua.State) c.Int {
+	c.Printf(c.Str("Coroutine started\n"))
+	L.Yield(0) // Pause the coroutine
+	c.Printf(c.Str("Coroutine resumed\n"))
+	return 0
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	co := L.Newthread()
+	L.Pushcfunction(coroutineFunc)
+	L.Xmove(co, 1)
+
+	var nres c.Int
+
+	c.Printf(c.Str("Resuming coroutine for the first time\n"))
+	result := co.Resume(nil, 0, &nres)
+	if result == lua.YIELD {
+		c.Printf(c.Str("Coroutine yielded\n"))
+		result = co.Resume(nil, 0, &nres)
+		if result == 0 {
+			c.Printf(c.Str("Coroutine finished\n"))
+		}
+	}
+}
+
+/* Expected output:
+Resuming coroutine for the first time
+Coroutine started
+Coroutine yielded
+Coroutine finished
+*/

c/lua/_demo/coroutine/coroutine.go

@@ -36,8 +36,8 @@ func main() {
 	// Resume coroutine and handle yields
 	for {
 		status = co.Resume(nil, 0, &nres)
-		c.Printf(c.Str("Resuming coroutine %d...\n"), status)
 		if status == lua.YIELD {
+			c.Printf(c.Str("Resuming coroutine %d...\n"), status)
 			yieldValue := co.Tointeger(-1)
 			c.Printf(c.Str("Yield value: %d\n"), yieldValue)
 			co.Pop(1) // Clean up the stack
@@ -58,3 +58,23 @@ func main() {
 	finalStatus := co.Status()
 	c.Printf(c.Str("Final status of coroutine: %d\n"), finalStatus)
 }
+
+/* Expected output:
+Resuming coroutine...
+Resuming coroutine 1...
+Yield value: 1
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 2
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 3
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 4
+Coroutine is yieldable.
+Resuming coroutine 1...
+Yield value: 5
+Coroutine is yieldable.
+Final status of coroutine: 0
+*/

c/lua/_demo/metatable/metatable.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func toString(L *lua.State) c.Int {
+	L.Pushstring(c.Str("Hello from metatable!"))
+	return 1
+}
+
+func printStack(L *lua.State, message string) {
+	top := L.Gettop()
+	c.Printf(c.Str("%s - Stack size: %d\n"), c.AllocaCStr(message), c.Int(top))
+	for i := c.Int(1); i <= top; i++ {
+		t := L.Type(i)
+		switch t {
+		case c.Int(lua.STRING):
+			c.Printf(c.Str("  %d: string: %s\n"), c.Int(i), L.Tostring(i))
+		case c.Int(lua.BOOLEAN):
+			c.Printf(c.Str("  %d: boolean: %v\n"), c.Int(i), L.Toboolean(i))
+		case c.Int(lua.NUMBER):
+			c.Printf(c.Str("  %d: number: %f\n"), c.Int(i), L.Tonumber(i))
+		default:
+			c.Printf(c.Str("  %d: %s\n"), c.Int(i), L.Typename(t))
+		}
+	}
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+
+	L.Newtable()
+	printStack(L, "After creating main table")
+
+	L.Newtable()
+	printStack(L, "After creating metatable")
+
+	L.Pushcfunction(toString)
+	printStack(L, "After Push CFunction")
+
+	L.Setfield(-2, c.Str("__tostring"))
+	printStack(L, "After setting __tostring")
+
+	if L.Setmetatable(-2) == 0 {
+		c.Printf(c.Str("Failed to set metatable\n"))
+	}
+	printStack(L, "After setting metatable")
+
+	L.Setglobal(c.Str("obj"))
+	printStack(L, "After setting global obj")
+
+	testcode := c.Str(`
+		if obj == nil then
+			print('obj is not defined')
+		else
+			local mt = getmetatable(obj)
+			if not mt then
+				print('Metatable not set')
+			elseif not mt.__tostring then
+				print('__tostring not set in metatable')
+			else
+				print(mt.__tostring(obj))
+			end
+		end
+	`)
+
+	if L.Dostring(testcode) != lua.OK {
+		c.Printf(c.Str("Error: %s\n"), L.Tostring(-1))
+	}
+
+	L.Getglobal(c.Str("obj"))
+	if L.Getmetatable(-1) != 0 {
+		c.Printf(c.Str("Metatable get success\n"))
+		L.Pushstring(c.Str("__tostring"))
+		L.Gettable(-2)
+		if L.Isfunction(-1) {
+			c.Printf(c.Str("__tostring function found in metatable\n"))
+			if L.Iscfunction(-1) != 0 {
+				c.Printf(c.Str("__tostring is a C function\n"))
+				cfunc := L.Tocfunction(-1)
+				if cfunc != nil {
+					c.Printf(c.Str("Successfully retrieved __tostring C function pointer\n"))
+					L.Pushcfunction(cfunc)
+					if L.Call(0, 1) == lua.OK {
+						result := L.Tostring(-1)
+						c.Printf(c.Str("Result of calling __tostring: %s\n"), result)
+					}
+				}
+			}
+		} else {
+			c.Printf(c.Str("__tostring function not found in metatable\n"))
+		}
+	} else {
+		c.Printf(c.Str("No metatable found using GetTable\n"))
+	}
+}
+
+/* Expected output:
+After creating main table - Stack size: 1
+  1: table
+After creating metatable - Stack size: 2
+  1: table
+  2: table
+After Push CFunction - Stack size: 3
+  1: table
+  2: table
+  3: function
+After setting __tostring - Stack size: 2
+  1: table
+  2: table
+After setting metatable - Stack size: 1
+  1: table
+After setting global obj - Stack size: 0
+Hello from metatable!
+Metatable get success
+__tostring function found in metatable
+__tostring is a C function
+Successfully retrieved __tostring C function pointer
+Result of calling __tostring: Hello from metatable!
+*/

c/lua/lua.go

@@ -41,17 +41,17 @@ type State struct {
 // ** basic types
 // */
 const (
-	NONE          = int(-1)
+	NONE          c.Int = -1
-	NIL           = int(0)
+	NIL           c.Int = 0
-	BOOLEAN       = int(1)
+	BOOLEAN       c.Int = 1
-	LIGHTUSERDATA = int(2)
+	LIGHTUSERDATA c.Int = 2
-	NUMBER        = int(3)
+	NUMBER        c.Int = 3
-	STRING        = int(4)
+	STRING        c.Int = 4
-	TABLE         = int(5)
+	TABLE         c.Int = 5
-	FUNCTION      = int(6)
+	FUNCTION      c.Int = 6
-	USERDATA      = int(7)
+	USERDATA      c.Int = 7
-	THREAD        = int(8)
+	THREAD        c.Int = 8
-	UMTYPES       = int(9)
+	UMTYPES       c.Int = 9
 )
 
 // /* minimum Lua stack available to a C function */
@@ -78,13 +78,15 @@ type Integer = c.Int
 type Unsigned = c.Uint
 
 // /* type for continuation-function contexts */
-// TODO(zzy): Context may not be c.Int
+type KContext = c.Pointer
-type KContext c.Int
 
 // /*
 // ** Type for C functions registered with Lua
 // */
 
+// llgo:type C
+type CFunction func(L *State) c.Int
+
 // /*
 // ** Type for continuation functions
 // */
@@ -144,7 +146,6 @@ type KFunction func(L *State, status c.Int, ctx KContext) c.Int
 func (L *State) Close() {}
 
 // State *(lua_newstate) (lua_Alloc f, void *ud);
-// State *(lua_newthread) (State *L);
 
 // llgo:link (*State).Newthread C.lua_newthread
 func (L *State) Newthread() *State { return nil }
@@ -185,9 +186,6 @@ func (L *State) Xmove(to *State, n c.Int) {}
 // /*
 // ** access functions (stack -> C)
 // */
-// LUA_API int             (lua_isinteger) (State *L, int idx);
-// llgo:link (*State).Isinteger C.lua_isinteger
-func (L *State) Isinteger(idx c.Int) c.Int { return 0 }
 
 // llgo:link (*State).Isnumber C.lua_isnumber
 func (L *State) Isnumber(idx c.Int) c.Int { return 0 }
@@ -195,11 +193,17 @@ func (L *State) Isnumber(idx c.Int) c.Int { return 0 }
 // llgo:link (*State).Isstring C.lua_isstring
 func (L *State) Isstring(idx c.Int) c.Int { return 0 }
 
-// TODO(zzy):add to demo
+// llgo:link (*State).Iscfunction C.lua_iscfunction
+func (L *State) Iscfunction(idx c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Isinteger C.lua_isinteger
+func (L *State) Isinteger(idx c.Int) c.Int { return 0 }
+
+// LUA_API int             (lua_isuserdata) (State *L, int idx);
+
 // llgo:link (*State).Type C.lua_type
 func (L *State) Type(idx c.Int) c.Int { return 0 }
 
-// TODO(zzy)
 // llgo:link (*State).Typename C.lua_typename
 func (L *State) Typename(tp c.Int) *c.Char { return nil }
 
@@ -215,11 +219,11 @@ func (L *State) Toboolean(idx c.Int) bool { return false }
 // llgo:link (*State).Tolstring C.lua_tolstring
 func (L *State) Tolstring(idx c.Int, len *c.Ulong) *c.Char { return nil }
 
-// LUA_API int             (lua_iscfunction) (State *L, int idx);
-// LUA_API int             (lua_isuserdata) (State *L, int idx);
-
 // LUA_API lua_Unsigned    (lua_rawlen) (State *L, int idx);
-// LUA_API lua_CFunction   (lua_tocfunction) (State *L, int idx);
+
+// llgo:link (*State).Tocfunction C.lua_tocfunction
+func (L *State) Tocfunction(idx c.Int) CFunction { return nil }
+
 // LUA_API void	       *(lua_touserdata) (State *L, int idx);
 // LUA_API State      *(lua_tothread) (State *L, int idx);
 // LUA_API const void     *(lua_topointer) (State *L, int idx);
@@ -240,24 +244,21 @@ func (L *State) Pushnumber(n Number) {}
 // llgo:link (*State).Pushinteger C.lua_pushinteger
 func (L *State) Pushinteger(n Integer) {}
 
-// llgo:link (*State).Pushstring C.lua_pushstring
-func (L *State) Pushstring(s *c.Char) *c.Char {
-	return nil
-}
-
 // llgo:link (*State).Pushlstring C.lua_pushlstring
-func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char {
+func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char { return nil }
-	return nil
+
-}
+// llgo:link (*State).Pushstring C.lua_pushstring
+func (L *State) Pushstring(s *c.Char) *c.Char { return nil }
 
 // llgo:link (*State).Pushfstring C.lua_pushfstring
 func (L *State) Pushfstring(format *c.Char, __llgo_va_list ...any) *c.Char { return nil }
 
+// llgo:link (*State).Pushcclosure C.lua_pushcclosure
+func (L *State) Pushcclosure(fn CFunction, n c.Int) {}
+
 // llgo:link (*State).Pushboolean C.lua_pushboolean
 func (L *State) Pushboolean(b c.Int) {}
 
-//const char *(lua_pushvfstring) (State *L, const char *fmt,va_list argp);
-//void  (lua_pushcclosure) (State *L, lua_CFunction fn, int n);
 //void  (lua_pushlightuserdata) (State *L, void *p);
 //int   (lua_pushthread) (State *L);
 
@@ -274,23 +275,25 @@ func (L *State) Gettable(idx c.Int) c.Int { return 0 }
 // llgo:link (*State).Getfield C.lua_getfield
 func (L *State) Getfield(idx c.Int, k *c.Char) c.Int { return 0 }
 
-// llgo:link (*State).Createtable C.lua_createtable
-func (L *State) Createtable(narr c.Int, nrec c.Int) {}
-
 // LUA_API int (lua_geti) (State *L, int idx, lua_Integer n);
 // LUA_API int (lua_rawget) (State *L, int idx);
 // LUA_API int (lua_rawgeti) (State *L, int idx, lua_Integer n);
 // LUA_API int (lua_rawgetp) (State *L, int idx, const void *p);
 
+// llgo:link (*State).Createtable C.lua_createtable
+func (L *State) Createtable(narr c.Int, nrec c.Int) {}
+
 // LUA_API void *(lua_newuserdatauv) (State *L, size_t sz, int nuvalue);
-// LUA_API int   (lua_getmetatable) (State *L, int objindex);
+
+// llgo:link (*State).Getmetatable C.lua_getmetatable
+func (L *State) Getmetatable(objindex c.Int) c.Int { return 0 }
+
 // LUA_API int  (lua_getiuservalue) (State *L, int idx, int n);
 
 // /*
 // ** set functions (stack -> Lua)
 // */
 
-// TODO(zzy):add to demo
 // llgo:link (*State).Setglobal C.lua_setglobal
 func (L *State) Setglobal(name *c.Char) {}
 
@@ -304,25 +307,34 @@ func (L *State) Setfield(idx c.Int, k *c.Char) {}
 //void  (lua_rawset) (State *L, int idx);
 //void  (lua_rawseti) (State *L, int idx, lua_Integer n);
 //void  (lua_rawsetp) (State *L, int idx, const void *p);
-//int   (lua_setmetatable) (State *L, int objindex);
+
+// llgo:link (*State).Setmetatable C.lua_setmetatable
+func (L *State) Setmetatable(objindex c.Int) c.Int { return 0 }
+
 //int   (lua_setiuservalue) (State *L, int idx, int n);
 
 // /*
 // ** 'load' and 'call' functions (load and run Lua code)
 // */
 
+// llgo:link (*State).Callk C.lua_callk
+func (L *State) Callk(nargs c.Int, nresults c.Int, ctx KContext, k KFunction) c.Int {
+	return 0
+}
+
+func (L *State) Call(nargs c.Int, nresults c.Int) c.Int {
+	return L.Callk(nargs, nresults, nil, nil)
+}
+
 // llgo:link (*State).Pcallk C.lua_pcallk
-func (L *State) Pcallk(nargs c.Int, nresults c.Int, errfunc c.Int, ctx KContext, k *KFunction) c.Int {
+func (L *State) Pcallk(nargs c.Int, nresults c.Int, errfunc c.Int, ctx KContext, k KFunction) c.Int {
 	return 0
 }
 
 func (L *State) Pcall(nargs c.Int, nresults c.Int, errfunc c.Int) c.Int {
-	return L.Pcallk(nargs, nresults, errfunc, KContext(c.Int(0)), nil)
+	return L.Pcallk(nargs, nresults, errfunc, nil, nil)
 }
 
-// void  (lua_callk) (State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k);
-// #define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
-
 // int   (lua_load) (State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode);
 
 // int (lua_dump) (State *L, lua_Writer writer, void *data, int strip);
@@ -340,9 +352,9 @@ func (L *State) Status() c.Int { return 0 }
 // llgo:link (*State).Isyieldable C.lua_isyieldable
 func (L *State) Isyieldable() c.Int { return 0 }
 
-// TODO(zzy)
+// llgo:link (*State).Yieldk C.lua_yieldk
-// int  (lua_yieldk)     (State *L, int nresults, lua_KContext ctx, lua_KFunction k);
+func (L *State) Yieldk(nresults c.Int, ctx KContext, k KFunction) c.Int { return 0 }
-// #define lua_yield(L,n)	lua_yieldk(L, (n), 0, NULL)
+func (L *State) Yield(nresults c.Int) c.Int                             { return L.Yieldk(nresults, nil, nil) }
 
 // /*
 // ** Warning-related functions
@@ -396,11 +408,17 @@ func (L *State) Next(idx c.Int) c.Int { return 0 }
 // ** ===============================================================
 // */
 
-func (L *State) Tonumber(idx c.Int) Number    { return L.Tonumberx(idx, nil) }
+// #define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
-func (L *State) Tostring(idx c.Int) *c.Char   { return L.Tolstring(idx, nil) }
+
-func (L *State) Tointeger(idx c.Int) Integer  { return L.Tointegerx(idx, nil) }
+func (L *State) Tonumber(idx c.Int) Number   { return L.Tonumberx(idx, nil) }
-func (L *State) Pop(n c.Int)                  { L.Settop(-(n) - 1) }
+func (L *State) Tostring(idx c.Int) *c.Char  { return L.Tolstring(idx, nil) }
-func (L *State) Newtable()                    { L.Createtable(0, 0) }
+func (L *State) Tointeger(idx c.Int) Integer { return L.Tointegerx(idx, nil) }
+func (L *State) Pop(n c.Int)                 { L.Settop(-(n) - 1) }
+func (L *State) Newtable()                   { L.Createtable(0, 0) }
+
+// #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+func (L *State) Pushcfunction(f CFunction) { L.Pushcclosure(f, 0) }
+
 func (L *State) Isfunction(n c.Int) bool      { return L.Type(n) == c.Int(FUNCTION) }
 func (L *State) Istable(n c.Int) bool         { return L.Type(n) == c.Int(TABLE) }
 func (L *State) Islightuserdata(n c.Int) bool { return L.Type(n) == c.Int(LIGHTUSERDATA) }
@@ -410,20 +428,11 @@ func (L *State) Isthread(n c.Int) bool        { return L.Type(n) == c.Int(THREAD
 func (L *State) Isnone(n c.Int) bool          { return L.Type(n) == c.Int(NONE) }
 func (L *State) Isnoneornil(n c.Int) bool     { return L.Type(n) <= 0 }
 
-// #define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
-
-// #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
-
-// #define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
-
 // #define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
-
 // #define lua_pushglobaltable(L)  ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
 
 // #define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
-
 // #define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
-
 // #define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
 
 // /* }============================================================== */

c/neco/README.md

@@ -0,0 +1,8 @@
+llgo wrapper of tidwall/neco
+=====
+
+## How to update source to llgo
+
+```sh
+TODO
+```

c/net/net.go

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-package socket
+package net
 
 import (
-	_ "unsafe"
+	"unsafe"
 
 	"github.com/goplus/llgo/c"
 )
@@ -80,6 +80,30 @@ const (
 	SOCK_SEQPACKET = 5 // sequenced packet stream
 )
 
+const (
+	EAI_ADDRFAMILY = iota + 1 /* address family for hostname not supported */
+	EAI_AGAIN                 /* temporary failure in name resolution */
+	EAI_BADFLAGS              /* invalid value for ai_flags */
+	EAI_FAIL                  /* non-recoverable failure in name resolution */
+	EAI_FAMILY                /* ai_family not supported */
+	EAI_MEMORY                /* memory allocation failure */
+	EAI_NODATA                /* no address associated with hostname */
+	EAI_NONAME                /* hostname nor servname provided, or not known */
+	EAI_SERVICE               /* servname not supported for ai_socktype */
+	EAI_SOCKTYPE              /* ai_socktype not supported */
+	EAI_SYSTEM                /* system error returned in errno */
+	EAI_BADHINTS              /* invalid value for hints */
+	EAI_PROTOCOL              /* resolved protocol is unknown */
+	EAI_OVERFLOW              /* argument buffer overflow */
+)
+
+const (
+	ALIGNSIZE = unsafe.Sizeof(c.LongLong(0))
+	MAXSIZE   = 128
+	PAD1_SIZE = ALIGNSIZE - unsafe.Sizeof(byte(0)) - unsafe.Sizeof(byte(0))
+	PAD2_SIZE = MAXSIZE - unsafe.Sizeof(byte(0)) - unsafe.Sizeof(byte(0)) - PAD1_SIZE - ALIGNSIZE
+)
+
 // (TODO) merge to inet
 const INET_ADDRSTRLEN = 16
 
@@ -91,17 +115,37 @@ type SockaddrIn struct {
 	Zero   [8]c.Char
 }
 
+type SockaddrIn6 struct {
+	Len      uint8
+	Family   uint8
+	Port     uint16
+	Flowinfo c.Uint
+	Addr     In6Addr
+	ScopeId  c.Uint
+}
+
+type SockaddrStorage struct {
+	Len    uint8
+	Family uint8
+	pad1   [PAD1_SIZE]c.Char
+	align  c.LongLong
+	pad2   [PAD2_SIZE]c.Char
+}
+
 type InAddr struct {
 	Addr c.Uint
 }
 
+type In6Addr struct {
+	U6Addr [16]uint8
+}
+
 type SockAddr struct {
 	Len    uint8
 	Family uint8
 	Data   [14]c.Char
 }
 
-// (TODO) merge to netdb
 type Hostent struct {
 	Name     *c.Char  // official name of host
 	Aliases  **c.Char // null-terminated array of alternate names for the host
@@ -125,8 +169,6 @@ func Listen(sockfd c.Int, backlog c.Int) c.Int
 //go:linkname Accept C.accept
 func Accept(sockfd c.Int, addr *SockaddrIn, addrlen *c.Uint) c.Int
 
-// (TODO) merge to netdb
-//
 //go:linkname GetHostByName C.gethostbyname
 func GetHostByName(name *c.Char) *Hostent
 
@@ -135,10 +177,64 @@ func GetHostByName(name *c.Char) *Hostent
 //go:linkname InetNtop C.inet_ntop
 func InetNtop(af c.Int, src c.Pointer, dst *c.Char, size c.Uint) *c.Char
 
-func SwapInt16(data uint16) uint16 {
+//go:linkname InetAddr C.inet_addr
+func InetAddr(s *c.Char) c.Uint
+
+//go:linkname Send C.send
+func Send(c.Int, c.Pointer, uintptr, c.Int) c.Long
+
+//go:linkname Recv C.recv
+func Recv(c.Int, c.Pointer, uintptr, c.Int) c.Long
+
+//go:linkname SetSockOpt C.setsockopt
+func SetSockOpt(socket c.Int, level c.Int, optionName c.Int, optionValue c.Pointer, sockLen c.Uint) c.Int
+
+// -----------------------------------------------------------------------------
+
+type AddrInfo struct {
+	Flags     c.Int
+	Family    c.Int
+	SockType  c.Int
+	Protocol  c.Int
+	AddrLen   c.Uint
+	CanOnName *c.Char
+	Addr      *SockAddr
+	Next      *AddrInfo
+}
+
+//go:linkname Getaddrinfo C.getaddrinfo
+func Getaddrinfo(host *c.Char, port *c.Char, addrInfo *AddrInfo, result **AddrInfo) c.Int
+
+//go:linkname Freeaddrinfo C.freeaddrinfo
+func Freeaddrinfo(addrInfo *AddrInfo) c.Int
+
+// -----------------------------------------------------------------------------
+
+func swapInt16(data uint16) uint16 {
 	return (data << 8) | (data >> 8)
 }
 
-func Htons(x uint16) uint16 {
+func swapInt32(data c.Uint) c.Uint {
-	return SwapInt16(x)
+	return ((data & 0xff) << 24) |
+		((data & 0xff00) << 8) |
+		((data & 0xff0000) >> 8) |
+		((data & 0xff000000) >> 24)
 }
+
+func Htons(x uint16) uint16 {
+	return swapInt16(x)
+}
+
+func Ntohs(x uint16) uint16 {
+	return swapInt16(x)
+}
+
+func Htonl(x c.Uint) c.Uint {
+	return swapInt32(x)
+}
+
+func Ntohl(x c.Uint) c.Uint {
+	return swapInt32(x)
+}
+
+// -----------------------------------------------------------------------------

c/openssl/_demo/cbigintdemo/fib.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func newInt(n openssl.BN_ULONG) *openssl.BIGNUM {
+	ret := openssl.BNNew()
+	ret.SetWord(n)
+	return ret
+}
+
+func main() {
+	ctx := openssl.BN_CTXNew()
+	defer ctx.Free()
+
+	// Initialize two big ints with the first two numbers in the sequence.
+	a := newInt(0)
+	b := newInt(1)
+	defer a.Free()
+	defer b.Free()
+
+	// Initialize limit as 10^99, the smallest integer with 100 digits.
+	v10, v99 := newInt(10), newInt(99)
+	defer v10.Free()
+	defer v99.Free()
+
+	limit := openssl.BNNew()
+	defer limit.Free()
+
+	limit.Exp(v10, v99, ctx)
+
+	// Loop while a is smaller than 1e100.
+	for a.Cmp(limit) < 0 {
+		// Compute the next Fibonacci number, storing it in a.
+		a.Add(a, b)
+		// Swap a and b so that b is the next number in the sequence.
+		a, b = b, a
+	}
+	cstr := a.CStr()
+	c.Printf(c.Str("%s\n"), cstr) // 100-digit Fibonacci number
+	openssl.FreeCStr(cstr)
+}

c/openssl/_demo/chmacdemo/hmac.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	str := "Hello, World!"
+	key := "123456"
+	var lenKey = len(key)
+
+	var digest = make([]byte, openssl.EVP_MAX_MD_SIZE)
+	var digestLen c.Uint
+	ctx := openssl.NewHMAC_CTX()
+	if ctx == nil {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error creating HMAC_CTX"))
+		return
+	}
+	defer ctx.Free()
+	var ret c.Int = ctx.InitEx(unsafe.Pointer(unsafe.StringData(key)), c.Int(lenKey), openssl.EVP_sha256(), nil)
+	if ret == 0 {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error initializing HMAC_CTX"))
+		return
+	}
+	ret = ctx.UpdateString(str)
+	if ret == 0 {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error updating HMAC_CTX"))
+		return
+	}
+	ret = ctx.Final(unsafe.SliceData(digest), &digestLen)
+	if ret == 0 {
+		c.Fprintf(c.Stderr, c.Str("%s\n"), c.Str("Error finalizing HMAC_CTX"))
+		return
+	}
+	fmt.Printf("HMAC:%x\n", digest[:digestLen])
+}

c/openssl/_demo/cmd5demo/md5.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	var md5 openssl.MD5_CTX
+	var h = make([]byte, openssl.MD5_LBLOCK)
+	md5.Init()
+	md5.UpdateString("The fog is getting thicker!")
+	md5.UpdateString("And Leon's getting laaarger!")
+	md5.Final(unsafe.SliceData(h))
+	fmt.Printf("%x", h)
+}

c/openssl/_demo/cranddemo/rand.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	b := make([]byte, 10)
+
+	openssl.RANDBytes(b)
+	fmt.Printf("%x\n", b)
+
+	openssl.RANDPrivBytes(b)
+	fmt.Printf("%x\n", b)
+}

c/openssl/_demo/cshademo/sha.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+	str := "His money is twice tainted:"
+
+	var sha1 openssl.SHA_CTX
+	sha1.Init()
+	sha1.UpdateString(str)
+
+	h1 := make([]byte, openssl.SHA_DIGEST_LENGTH)
+	sha1.Final(unsafe.SliceData(h1))
+	fmt.Printf("%x\n", h1)
+
+	h2 := make([]byte, openssl.SHA_DIGEST_LENGTH)
+	openssl.SHA1String(str, unsafe.SliceData(h2))
+	fmt.Printf("%x\n", h2)
+
+	var sha256 openssl.SHA256_CTX
+	sha256.Init()
+	sha256.UpdateString(str)
+	h3 := make([]byte, openssl.SHA256_DIGEST_LENGTH)
+	sha256.Final(unsafe.SliceData(h3))
+	fmt.Printf("%x\n", h3)
+
+	h4 := make([]byte, openssl.SHA256_DIGEST_LENGTH)
+	openssl.SHA256String(str, unsafe.SliceData(h4))
+	fmt.Printf("%x\n", h4)
+
+	var sha512 openssl.SHA512_CTX
+	sha512.Init()
+	sha512.UpdateString("His money is twice tainted:")
+
+	h5 := make([]byte, openssl.SHA512_DIGEST_LENGTH)
+	sha512.Final(unsafe.SliceData(h5))
+	fmt.Printf("%x\n", h5)
+
+	h6 := make([]byte, openssl.SHA512_DIGEST_LENGTH)
+	openssl.SHA512String(str, unsafe.SliceData(h6))
+	fmt.Printf("%x\n", h6)
+
+	var sha224 openssl.SHA224_CTX
+	sha224.Init()
+	sha224.UpdateString(str)
+
+	h7 := make([]byte, openssl.SHA224_DIGEST_LENGTH)
+	sha224.Final(unsafe.SliceData(h7))
+	fmt.Printf("%x\n", h7)
+	h8 := make([]byte, openssl.SHA224_DIGEST_LENGTH)
+	openssl.SHA224String(str, unsafe.SliceData(h8))
+	fmt.Printf("%x\n", h8)
+
+	var sha384 openssl.SHA384_CTX
+	sha384.Init()
+	sha384.UpdateString(str)
+	h9 := make([]byte, openssl.SHA384_DIGEST_LENGTH)
+	sha384.Final(unsafe.SliceData(h9))
+	fmt.Printf("%x\n", h9)
+	h10 := make([]byte, openssl.SHA384_DIGEST_LENGTH)
+	openssl.SHA384String(str, unsafe.SliceData(h10))
+	fmt.Printf("%x\n", h10)
+}

c/openssl/_wrap/openssl.c

@@ -0,0 +1,5 @@
+#include <openssl/crypto.h>
+
+void opensslFree(void *ptr) {
+    OPENSSL_free(ptr);
+}

c/openssl/bio.go

@@ -0,0 +1,61 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+type BIO struct {
+	Unused [0]byte
+}
+
+// BIO *BIO_new_mem_buf(const void *buf, int len);
+//
+//go:linkname BIONewMemBuf C.BIO_new_mem_buf
+func BIONewMemBuf(buf unsafe.Pointer, len c.Int) *BIO
+
+// int BIO_free(BIO *a);
+//
+// llgo:link (*BIO).Free C.BIO_free
+func (*BIO) Free() c.Int { return 0 }
+
+// int BIO_up_ref(BIO *a);
+//
+// llgo:link (*BIO).UpRef C.BIO_up_ref
+func (*BIO) UpRef() c.Int { return 0 }
+
+// int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
+//
+// llgo:link (*BIO).ReadEx C.BIO_read_ex
+func (*BIO) ReadEx(data unsafe.Pointer, dlen uintptr, readbytes *uintptr) c.Int { return 0 }
+
+// int BIO_write(BIO *b, const void *data, int dlen);
+//
+// llgo:link (*BIO).Write C.BIO_write
+func (*BIO) Write(data unsafe.Pointer, dlen c.Int) c.Int { return 0 }
+
+// int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
+//
+// llgo:link (*BIO).WriteEx C.BIO_write_ex
+func (*BIO) WriteEx(data unsafe.Pointer, dlen uintptr, written *uintptr) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------

c/openssl/bn.go

@@ -0,0 +1,409 @@
+/*
+ * 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 openssl
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type BN_ULONG = uint64
+
+// -----------------------------------------------------------------------------
+
+type BN_CTX struct {
+	Unused [0]byte
+}
+
+// BN_CTX *BN_CTX_new(void);
+//
+//go:linkname BN_CTXNew C.BN_CTX_new
+func BN_CTXNew() *BN_CTX
+
+// BN_CTX *BN_CTX_secure_new(void);
+//
+//go:linkname BN_CTXSecureNew C.BN_CTX_secure_new
+func BN_CTXSecureNew() *BN_CTX
+
+// BN_CTX *BN_CTX_new_ex(OSSL_LIB_CTX *ctx);
+// BN_CTX *BN_CTX_secure_new_ex(OSSL_LIB_CTX *ctx);
+
+// void BN_CTX_free(BN_CTX *c);
+//
+// llgo:link (*BN_CTX).Free C.BN_CTX_free
+func (*BN_CTX) Free() {}
+
+// void BN_CTX_start(BN_CTX *ctx);
+//
+// llgo:link (*BN_CTX).Start C.BN_CTX_start
+func (*BN_CTX) Start() {}
+
+// BIGNUM *BN_CTX_get(BN_CTX *ctx);
+//
+// llgo:link (*BN_CTX).Get C.BN_CTX_get
+func (*BN_CTX) Get() *BIGNUM { return nil }
+
+// void BN_CTX_end(BN_CTX *ctx);
+//
+// llgo:link (*BN_CTX).End C.BN_CTX_end
+func (*BN_CTX) End() {}
+
+// -----------------------------------------------------------------------------
+
+type BIGNUM struct {
+	Unused [0]byte
+}
+
+// BIGNUM *BN_new(void);
+//
+//go:linkname BNNew C.BN_new
+func BNNew() *BIGNUM
+
+// BIGNUM *BN_secure_new(void);
+//
+//go:linkname BNSecureNew C.BN_secure_new
+func BNSecureNew() *BIGNUM
+
+// void BN_free(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Free C.BN_free
+func (*BIGNUM) Free() {}
+
+// void BN_clear_free(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).ClearFree C.BN_clear_free
+func (*BIGNUM) ClearFree() {}
+
+// void BN_clear(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Clear C.BN_clear
+func (*BIGNUM) Clear() {}
+
+// BIGNUM *BN_dup(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Dup C.BN_dup
+func (*BIGNUM) Dup() *BIGNUM { return nil }
+
+// BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Copy C.BN_copy
+func (*BIGNUM) Copy(b *BIGNUM) *BIGNUM { return nil }
+
+// void BN_swap(BIGNUM *a, BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Swap C.BN_swap
+func (*BIGNUM) Swap(b *BIGNUM) {}
+
+// int BN_is_zero(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsZero C.BN_is_zero
+func (*BIGNUM) IsZero() c.Int { return 0 }
+
+// void BN_zero_ex(BIGNUM *a);
+//
+// llgo:link (*BIGNUM).SetZero C.BN_zero_ex
+func (*BIGNUM) SetZero() {}
+
+// int BN_is_one(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsOne C.BN_is_one
+func (*BIGNUM) IsOne() c.Int { return 0 }
+
+// int BN_is_odd(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).IsOdd C.BN_is_odd
+func (*BIGNUM) IsOdd() c.Int { return 0 }
+
+// int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w);
+//
+// llgo:link (*BIGNUM).AbsIsWord C.BN_abs_is_word
+func (*BIGNUM) AbsIsWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_is_word(const BIGNUM *a, const BN_ULONG w);
+//
+// llgo:link (*BIGNUM).IsWord C.BN_is_word
+func (*BIGNUM) IsWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_set_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).SetWord C.BN_set_word
+func (*BIGNUM) SetWord(w BN_ULONG) c.Int { return 0 }
+
+// BN_ULONG BN_get_word(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).GetWord C.BN_get_word
+func (*BIGNUM) GetWord() BN_ULONG { return 0 }
+
+// BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).ModWord C.BN_mod_word
+func (*BIGNUM) ModWord(w BN_ULONG) BN_ULONG { return 0 }
+
+// BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).DivWord C.BN_div_word
+func (*BIGNUM) DivWord(w BN_ULONG) BN_ULONG { return 0 }
+
+// int BN_mul_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).MulWord C.BN_mul_word
+func (*BIGNUM) MulWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_add_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).AddWord C.BN_add_word
+func (*BIGNUM) AddWord(w BN_ULONG) c.Int { return 0 }
+
+// int BN_sub_word(BIGNUM *a, BN_ULONG w);
+//
+// llgo:link (*BIGNUM).SubWord C.BN_sub_word
+func (*BIGNUM) SubWord(w BN_ULONG) c.Int { return 0 }
+
+// char *BN_bn2hex(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Bn2hex C.BN_bn2hex
+func (*BIGNUM) Bn2hex() *c.Char { return nil }
+
+// char *BN_bn2dec(const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Bn2dec C.BN_bn2dec
+func (*BIGNUM) Bn2dec() *c.Char { return nil }
+
+// llgo:link (*BIGNUM).CStr C.BN_bn2dec
+func (*BIGNUM) CStr() *c.Char { return nil }
+
+// int BN_hex2bn(BIGNUM **a, const char *str);
+//
+//go:linkname BNHex2bn C.BN_hex2bn
+func BNHex2bn(a **BIGNUM, str *c.Char) c.Int
+
+// int BN_dec2bn(BIGNUM **a, const char *str);
+//
+//go:linkname BNDec2bn C.BN_dec2bn
+func BNDec2bn(a **BIGNUM, str *c.Char) c.Int
+
+// int BN_asc2bn(BIGNUM **a, const char *str);
+//
+//go:linkname BNAsc2bn C.BN_asc2bn
+func BNAsc2bn(a **BIGNUM, str *c.Char) c.Int
+
+// BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNBin2bn C.BN_bin2bn
+func BNBin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// BIGNUM *BN_signed_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNSignedBin2bn C.BN_signed_bin2bn
+func BNSignedBin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// int BN_bn2bin(const BIGNUM *a, unsigned char *to);
+//
+// llgo:link (*BIGNUM).Bn2bin C.BN_bn2bin
+func (bn *BIGNUM) Bn2bin(to *byte) c.Int { return 0 }
+
+// int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).Bn2binpad C.BN_bn2binpad
+func (bn *BIGNUM) Bn2binpad(to *byte, tolen c.Int) c.Int { return 0 }
+
+// int BN_signed_bn2bin(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).SignedBn2bin C.BN_signed_bn2bin
+func (bn *BIGNUM) SignedBn2bin(to *byte, tolen c.Int) c.Int { return 0 }
+
+// BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNLebin2bn C.BN_lebin2bn
+func BNLebin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// BIGNUM *BN_signed_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNSignedLebin2bn C.BN_signed_lebin2bn
+func BNSignedLebin2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).Bn2lebinpad C.BN_bn2lebinpad
+func (bn *BIGNUM) Bn2lebinpad(to *byte, tolen c.Int) c.Int { return 0 }
+
+// int BN_signed_bn2lebin(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).SignedBn2lebin C.BN_signed_bn2lebin
+func (bn *BIGNUM) SignedBn2lebin(to *byte, tolen c.Int) c.Int { return 0 }
+
+// BIGNUM *BN_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNNative2bn C.BN_native2bn
+func BNNative2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// BIGNUM *BN_signed_native2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNSignedNative2bn C.BN_signed_native2bn
+func BNSignedNative2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// int BN_bn2nativepad(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).Bn2nativepad C.BN_bn2nativepad
+func (bn *BIGNUM) Bn2nativepad(to *byte, tolen c.Int) c.Int { return 0 }
+
+// int BN_signed_bn2native(const BIGNUM *a, unsigned char *to, int tolen);
+//
+// llgo:link (*BIGNUM).SignedBn2native C.BN_signed_bn2native
+func (bn *BIGNUM) SignedBn2native(to *byte, tolen c.Int) c.Int { return 0 }
+
+// BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
+//
+//go:linkname BNMpi2bn C.BN_mpi2bn
+func BNMpi2bn(s *byte, len c.Int, ret *BIGNUM) *BIGNUM
+
+// int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
+//
+// llgo:link (*BIGNUM).Bn2mpi C.BN_bn2mpi
+func (bn *BIGNUM) Bn2mpi(to *byte) c.Int { return 0 }
+
+// int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Sub C.BN_sub
+func (*BIGNUM) Sub(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Add C.BN_add
+func (*BIGNUM) Add(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Usub C.BN_usub
+func (*BIGNUM) Usub(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Uadd C.BN_uadd
+func (*BIGNUM) Uadd(a, b *BIGNUM) c.Int { return 0 }
+
+// int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Mul C.BN_mul
+func (*BIGNUM) Mul(r, a, b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Sqr C.BN_sqr
+func (*BIGNUM) Sqr(r, a *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+/** BN_set_negative sets sign of a BIGNUM
+ * \param  b  pointer to the BIGNUM object
+ * \param  n  0 if the BIGNUM b should be positive and a value != 0 otherwise
+ */
+// void BN_set_negative(BIGNUM *b, int n);
+//
+// llgo:link (*BIGNUM).SetNegative C.BN_set_negative
+func (*BIGNUM) SetNegative(n c.Int) {}
+
+/** BN_is_negative returns 1 if the BIGNUM is negative
+ * \param  b  pointer to the BIGNUM object
+ * \return 1 if a < 0 and 0 otherwise
+ */
+// int BN_is_negative(const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).IsNegative C.BN_is_negative
+func (*BIGNUM) IsNegative() c.Int { return 0 }
+
+// int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Div C.BN_div
+func (*BIGNUM) Div(rem, m, d *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Nnmod C.BN_nnmod
+func (*BIGNUM) Nnmod(r, m, d *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_cmp(const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Cmp C.BN_cmp
+func (*BIGNUM) Cmp(b *BIGNUM) c.Int { return 0 }
+
+// int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
+//
+// llgo:link (*BIGNUM).Ucmp C.BN_ucmp
+func (*BIGNUM) Ucmp(b *BIGNUM) c.Int { return 0 }
+
+// int BN_is_bit_set(const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).IsBitSet C.BN_is_bit_set
+func (*BIGNUM) IsBitSet(n c.Int) c.Int { return 0 }
+
+// int BN_set_bit(BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).SetBit C.BN_set_bit
+func (*BIGNUM) SetBit(n c.Int) c.Int { return 0 }
+
+// int BN_clear_bit(BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).ClearBit C.BN_clear_bit
+func (*BIGNUM) ClearBit(n c.Int) c.Int { return 0 }
+
+// int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).Lshift C.BN_lshift
+func (*BIGNUM) Lshift(a *BIGNUM, n c.Int) c.Int { return 0 }
+
+// int BN_lshift1(BIGNUM *r, const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Lshift1 C.BN_lshift1
+func (*BIGNUM) Lshift1(a *BIGNUM) c.Int { return 0 }
+
+// int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
+//
+// llgo:link (*BIGNUM).Rshift C.BN_rshift
+func (*BIGNUM) Rshift(a *BIGNUM, n c.Int) c.Int { return 0 }
+
+// int BN_rshift1(BIGNUM *r, const BIGNUM *a);
+//
+// llgo:link (*BIGNUM).Rshift1 C.BN_rshift1
+func (*BIGNUM) Rshift1(a *BIGNUM) c.Int { return 0 }
+
+// int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Exp C.BN_exp
+func (*BIGNUM) Exp(a, p *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).ModExp C.BN_mod_exp
+func (*BIGNUM) ModExp(a, p, m *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).Gcd C.BN_gcd
+func (*BIGNUM) Gcd(a, b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// int BN_are_coprime(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
+//
+// llgo:link (*BIGNUM).AreCoprime C.BN_are_coprime
+func (*BIGNUM) AreCoprime(b *BIGNUM, ctx *BN_CTX) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+type BN_GENCB struct {
+	Unused [0]byte
+}
+
+// -----------------------------------------------------------------------------

c/openssl/err.go

@@ -0,0 +1,156 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+/*-
+ * The error code packs differently depending on if it records a system
+ * error or an OpenSSL error.
+ *
+ * A system error packs like this (we follow POSIX and only allow positive
+ * numbers that fit in an |int|):
+ *
+ * +-+-------------------------------------------------------------+
+ * |1|                     system error number                     |
+ * +-+-------------------------------------------------------------+
+ *
+ * An OpenSSL error packs like this:
+ *
+ * <---------------------------- 32 bits -------------------------->
+ *    <--- 8 bits ---><------------------ 23 bits ----------------->
+ * +-+---------------+---------------------------------------------+
+ * |0|    library    |                    reason                   |
+ * +-+---------------+---------------------------------------------+
+ *
+ * A few of the reason bits are reserved as flags with special meaning:
+ *
+ *                    <5 bits-<>--------- 19 bits ----------------->
+ *                   +-------+-+-----------------------------------+
+ *                   | rflags| |          reason                   |
+ *                   +-------+-+-----------------------------------+
+ *                            ^
+ *                            |
+ *                           ERR_RFLAG_FATAL = ERR_R_FATAL
+ *
+ * The reason flags are part of the overall reason code for practical
+ * reasons, as they provide an easy way to place different types of
+ * reason codes in different numeric ranges.
+ *
+ * The currently known reason flags are:
+ *
+ * ERR_RFLAG_FATAL      Flags that the reason code is considered fatal.
+ *                      For backward compatibility reasons, this flag
+ *                      is also the code for ERR_R_FATAL (that reason
+ *                      code served the dual purpose of flag and reason
+ *                      code in one in pre-3.0 OpenSSL).
+ * ERR_RFLAG_COMMON     Flags that the reason code is common to all
+ *                      libraries.  All ERR_R_ macros must use this flag,
+ *                      and no other _R_ macro is allowed to use it.
+ */
+type Errno c.Ulong
+
+// ERR_get_error returns the earliest error code from the thread's error queue and
+// removes the entry. This function can be called repeatedly until there are no more
+// error codes to return.
+//
+// unsigned long ERR_get_error(void);
+//
+//go:linkname ERRGetError C.ERR_get_error
+func ERRGetError() Errno
+
+// ERR_get_error_all() is the same as ERR_get_error(), but on success it additionally
+// stores the filename, line number and function where the error occurred in *file,
+// *line and *func, and also extra text and flags in *data, *flags. If any of those
+// parameters are NULL, it will not be changed.
+//
+// unsigned long ERR_get_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRGetErrorAll C.ERR_get_error_all
+func ERRGetErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// unsigned long ERR_peek_error(void);
+//
+//go:linkname ERRPeekError C.ERR_peek_error
+func ERRPeekError() Errno
+
+// unsigned long ERR_peek_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRPeekErrorAll C.ERR_peek_error_all
+func ERRPeekErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// unsigned long ERR_peek_last_error(void);
+//
+//go:linkname ERRPeekLastError C.ERR_peek_last_error
+func ERRPeekLastError() Errno
+
+// unsigned long ERR_peek_last_error_all(
+// const char **file, int *line, const char **func, const char **data, int *flags);
+//
+//go:linkname ERRPeekLastErrorAll C.ERR_peek_last_error_all
+func ERRPeekLastErrorAll(
+	file **c.Char, line *c.Int, function **c.Char, data **c.Char, flags *c.Int) Errno
+
+// void ERR_clear_error(void);
+//
+//go:linkname ERRClearError C.ERR_clear_error
+func ERRClearError()
+
+// ERR_error_string() generates a human-readable string representing the error code e,
+// and places it at buf. buf must be at least 256 bytes long.
+//
+// char *ERR_error_string(unsigned long e, char *buf);
+//
+//go:linkname ERRErrorString C.ERR_error_string
+func ERRErrorString(e Errno, buf *c.Char) *c.Char
+
+// ERR_lib_error_string() and ERR_reason_error_string() return the library name and
+// reason string respectively.
+//
+// const char *ERR_lib_error_string(unsigned long e);
+//
+//go:linkname ERRLibErrorString C.ERR_lib_error_string
+func ERRLibErrorString(e Errno) *c.Char
+
+// const char *ERR_reason_error_string(unsigned long e);
+//
+//go:linkname ERRReasonErrorString C.ERR_reason_error_string
+func ERRReasonErrorString(e Errno) *c.Char
+
+// void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u), void *u);
+//
+// [pid]:error:[error code]:[library name]:[function name]:[reason string]:[filename]:[line]:[optional text message]
+//
+//go:linkname ERRPrintErrorsCb C.ERR_print_errors_cb
+func ERRPrintErrorsCb(cb func(str *c.Char, len uintptr, u unsafe.Pointer) c.Int, u unsafe.Pointer)
+
+// void ERR_print_errors_fp(FILE *fp);
+//
+//go:linkname ERRPrintErrorsFp C.ERR_print_errors_fp
+func ERRPrintErrorsFp(fp c.FilePtr)
+
+// -----------------------------------------------------------------------------

c/openssl/hmac.go

@@ -0,0 +1,133 @@
+package openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	EVP_MAX_MD_SIZE = 64 /* longest known is SHA512 */
+)
+
+// -----------------------------------------------------------------------------
+
+type EVP_MD struct {
+	Unused [0]byte
+}
+
+// const EVP_MD *EVP_sha1(void)
+//
+//go:linkname EVP_sha1 C.EVP_sha1
+func EVP_sha1() *EVP_MD
+
+// const EVP_MD *EVP_sha224(void)
+//
+//go:linkname EVP_sha224 C.EVP_sha224
+func EVP_sha224() *EVP_MD
+
+// func EVP_sha256() *EVP_MD
+//
+//go:linkname EVP_sha256 C.EVP_sha256
+func EVP_sha256() *EVP_MD
+
+// const EVP_MD *EVP_sha512_224(void)
+//
+//go:linkname EVP_sha512_224 C.EVP_sha512_224
+func EVP_sha512_224() *EVP_MD
+
+// const EVP_MD *EVP_sha512_256(void)
+//
+//go:linkname EVP_sha512_256 C.EVP_sha512_256
+func EVP_sha512_256() *EVP_MD
+
+// const EVP_MD *EVP_sha384(void)
+//
+//go:linkname EVP_sha384 C.EVP_sha384
+func EVP_sha384() *EVP_MD
+
+// const EVP_MD *EVP_sha512(void)
+//
+//go:linkname EVP_sha512 C.EVP_sha512
+func EVP_sha512() *EVP_MD
+
+// -----------------------------------------------------------------------------
+
+type HMAC_CTX struct {
+	Unused [0]byte
+}
+
+// OSSL_DEPRECATEDIN_3_0 HMAC_CTX *HMAC_CTX_new(void);
+//
+//go:linkname NewHMAC_CTX C.HMAC_CTX_new
+func NewHMAC_CTX() *HMAC_CTX
+
+// OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_free(HMAC_CTX *ctx);
+//
+// llgo:link (*HMAC_CTX).Free C.HMAC_CTX_free
+func (ctx *HMAC_CTX) Free() {}
+
+// OSSL_DEPRECATEDIN_3_0 size_t HMAC_size(const HMAC_CTX *e);
+//
+// llgo:link (*HMAC_CTX).Size C.HMAC_size
+func (ctx *HMAC_CTX) Size() uintptr { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int HMAC_CTX_reset(HMAC_CTX *ctx);
+//
+// llgo:link (*HMAC_CTX).Reset C.HMAC_CTX_reset
+func (ctx *HMAC_CTX) Reset() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_1_1_0 __owur int HMAC_Init(HMAC_CTX *ctx,
+// const void *key, int len,
+// const EVP_MD *md);
+//
+// llgo:link (*HMAC_CTX).Init C.HMAC_Init
+func (ctx *HMAC_CTX) Init(key unsafe.Pointer, len c.Int, md *EVP_MD) c.Int { return 0 }
+
+func (ctx *HMAC_CTX) InitBytes(key []byte, md *EVP_MD) c.Int {
+	return ctx.Init(unsafe.Pointer(unsafe.SliceData(key)), c.Int(len(key)), md)
+}
+
+func (ctx *HMAC_CTX) InitString(key string, md *EVP_MD) c.Int {
+	return ctx.Init(unsafe.Pointer(unsafe.StringData(key)), c.Int(len(key)), md)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
+// const EVP_MD *md, ENGINE *impl);
+//
+// llgo:link (*HMAC_CTX).InitEx C.HMAC_Init_ex
+func (ctx *HMAC_CTX) InitEx(key unsafe.Pointer, len c.Int, md *EVP_MD, impl unsafe.Pointer) c.Int {
+	return 0
+}
+
+// OSSL_DEPRECATEDIN_3_0 int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
+// size_t len);
+//
+// llgo:link (*HMAC_CTX).Update C.HMAC_Update
+func (ctx *HMAC_CTX) Update(data unsafe.Pointer, len uintptr) c.Int { return 0 }
+
+func (ctx *HMAC_CTX) UpdateBytes(data []byte) c.Int {
+	return ctx.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (ctx *HMAC_CTX) UpdateString(data string) c.Int {
+	return ctx.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
+// unsigned int *len);
+//
+// llgo:link (*HMAC_CTX).Final C.HMAC_Final
+func (ctx *HMAC_CTX) Final(md *byte, len *c.Uint) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 __owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
+//
+// llgo:link (*HMAC_CTX).Copy C.HMAC_CTX_copy
+func (ctx *HMAC_CTX) Copy(sctx *HMAC_CTX) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
+//
+// llgo:link (*HMAC_CTX).SetFlags C.HMAC_CTX_set_flags
+func (ctx *HMAC_CTX) SetFlags(flags c.Ulong) {}
+
+// -----------------------------------------------------------------------------

c/openssl/md5.go

@@ -0,0 +1,85 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+const (
+	MD5_CBLOCK = 64
+	MD5_LBLOCK = MD5_CBLOCK / 4
+)
+
+// -----------------------------------------------------------------------------
+
+type MD5_LONG = c.Uint
+
+type MD5_CTX struct {
+	A, B, C, D MD5_LONG
+	Nl, Nh     MD5_LONG
+	Data       [MD5_LBLOCK]MD5_LONG
+	Num        c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Init(MD5_CTX *c);
+//
+// llgo:link (*MD5_CTX).Init C.MD5_Init
+func (c *MD5_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Update(MD5_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*MD5_CTX).Update C.MD5_Update
+func (c *MD5_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *MD5_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *MD5_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int MD5_Final(unsigned char *md, MD5_CTX *c);
+//
+//go:linkname md5Final C.MD5_Final
+func md5Final(md *byte, c *MD5_CTX) c.Int
+
+func (c *MD5_CTX) Final(md *byte) c.Int {
+	return md5Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname MD5 C.MD5
+func MD5(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func MD5Bytes(data []byte, md *byte) *byte {
+	return MD5(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func MD5String(data string, md *byte) *byte {
+	return MD5(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void MD5_Transform(MD5_CTX *c, const unsigned char *b);
+
+// -----------------------------------------------------------------------------

c/openssl/openssl.go

@@ -0,0 +1,38 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+const (
+	LLGoFiles   = "$(pkg-config --cflags openssl): _wrap/openssl.c"
+	LLGoPackage = "link: $(pkg-config --libs openssl); -lssl -lcrypto"
+)
+
+//go:linkname Free C.opensslFree
+func Free(ptr unsafe.Pointer)
+
+//go:linkname FreeCStr C.opensslFree
+func FreeCStr(ptr *c.Char)
+
+// -----------------------------------------------------------------------------

c/openssl/pem.go

@@ -0,0 +1,37 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// typedef int (*pem_password_cb)(char *buf, int size, int rwflag, void *userdata);
+//
+// llgo:type C
+type PemPasswordCb func(buf *c.Char, size, rwflag c.Int, userdata unsafe.Pointer) c.Int
+
+// RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x, pem_password_cb *cb, void *u);
+//
+//go:linkname PEMReadBioRSAPrivateKey C.PEM_read_bio_RSAPrivateKey
+func PEMReadBioRSAPrivateKey(bp *BIO, x **RSA, cb PemPasswordCb, u unsafe.Pointer) *RSA
+
+// -----------------------------------------------------------------------------

c/openssl/rand.go

@@ -0,0 +1,80 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// int RAND_bytes(unsigned char *buf, int num);
+//
+//go:linkname RANDBufferWithLen C.RAND_bytes
+func RANDBufferWithLen(buf *byte, num c.Int) c.Int
+
+func RANDBytes(buf []byte) c.Int {
+	return RANDBufferWithLen(unsafe.SliceData(buf), c.Int(len(buf)))
+}
+
+// int RAND_priv_bytes(unsigned char *buf, int num);
+//
+//go:linkname RANDPrivBufferWithLen C.RAND_priv_bytes
+func RANDPrivBufferWithLen(buf *byte, num c.Int) c.Int
+
+func RANDPrivBytes(buf []byte) c.Int {
+	return RANDPrivBufferWithLen(unsafe.SliceData(buf), c.Int(len(buf)))
+}
+
+// void RAND_seed(const void *buf, int num);
+//
+//go:linkname RANDSeed C.RAND_seed
+func RANDSeed(buf unsafe.Pointer, num c.Int)
+
+// void RAND_keep_random_devices_open(int keep);
+//
+//go:linkname RANDKeepRandomDevicesOpen C.RAND_keep_random_devices_open
+func RANDKeepRandomDevicesOpen(keep c.Int)
+
+// int RAND_load_file(const char *file, long max_bytes);
+//
+//go:linkname RANDLoadFile C.RAND_load_file
+func RANDLoadFile(file *c.Char, maxBytes c.Long) c.Int
+
+// int RAND_write_file(const char *file);
+//
+//go:linkname RANDWriteFile C.RAND_write_file
+func RANDWriteFile(file *c.Char) c.Int
+
+// const char *RAND_file_name(char *file, size_t num);
+//
+//go:linkname RANDFileName C.RAND_file_name
+func RANDFileName(file *c.Char, num uintptr) *c.Char
+
+// int RAND_status(void);
+//
+//go:linkname RANDStatus C.RAND_status
+func RANDStatus() c.Int
+
+// int RAND_poll(void);
+//
+//go:linkname RANDPoll C.RAND_poll
+func RANDPoll() c.Int
+
+// -----------------------------------------------------------------------------

c/openssl/rsa.go

@@ -0,0 +1,305 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+type RSA_METHOD struct {
+	Unused [0]byte
+}
+
+// OSSL_DEPRECATEDIN_3_0 RSA_METHOD *RSA_meth_new(const char *name, int flags);
+//
+//go:linkname RSAMethNew C.RSA_meth_new
+func RSAMethNew(name *byte, flags c.Int) *RSA_METHOD
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_meth_free(RSA_METHOD *meth);
+//
+// llgo:link (*RSA_METHOD).Free C.RSA_meth_free
+func (*RSA_METHOD) Free() {}
+
+// OSSL_DEPRECATEDIN_3_0
+// int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
+//
+// llgo:link (*RSA_METHOD).SetInit C.RSA_meth_set_init
+func (*RSA_METHOD) SetInit(init func(rsa *RSA) c.Int) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0
+// int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
+//
+// llgo:link (*RSA_METHOD).SetFinish C.RSA_meth_set_finish
+func (*RSA_METHOD) SetFinish(finish func(rsa *RSA) c.Int) c.Int { return 0 }
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
+                         int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa,
+                                         BN_CTX *ctx));
+*/
+// llgo:link (*RSA_METHOD).SetModExp C.RSA_meth_set_mod_exp
+func (*RSA_METHOD) SetModExp(modExp func(
+	r0 *BIGNUM, i *BIGNUM, rsa *RSA, ctx *BN_CTX) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
+                            int (*bn_mod_exp) (BIGNUM *r,
+                                               const BIGNUM *a,
+                                               const BIGNUM *p,
+                                               const BIGNUM *m,
+                                               BN_CTX *ctx,
+                                               BN_MONT_CTX *m_ctx));
+//-llgo:link (*RSA_METHOD).SetBnModExp C.RSA_meth_set_bn_mod_exp
+func (*RSA_METHOD) SetBnModExp(bnModExp func(
+	r *BIGNUM, a *BIGNUM, p *BIGNUM, m *BIGNUM, ctx *BN_CTX, mCtx *BN_MONT_CTX) c.Int) c.Int {
+	return 0
+}
+*/
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
+                         int (*pub_enc) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPubEnc C.RSA_meth_set_pub_enc
+func (*RSA_METHOD) SetPubEnc(pubEnc func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
+                         int (*pub_dec) (int flen, const unsigned char *from,
+                                         unsigned char *to, RSA *rsa,
+                                         int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPubDec C.RSA_meth_set_pub_dec
+func (*RSA_METHOD) SetPubDec(pubDec func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
+                          int (*priv_enc) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPrivEnc C.RSA_meth_set_priv_enc
+func (*RSA_METHOD) SetPrivEnc(privEnc func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
+                          int (*priv_dec) (int flen, const unsigned char *from,
+                                           unsigned char *to, RSA *rsa,
+                                           int padding));
+*/
+// llgo:link (*RSA_METHOD).SetPrivDec C.RSA_meth_set_priv_dec
+func (*RSA_METHOD) SetPrivDec(privDec func(
+	flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_sign(RSA_METHOD *rsa,
+                      int (*sign) (int type, const unsigned char *m,
+                                   unsigned int m_length,
+                                   unsigned char *sigret, unsigned int *siglen,
+                                   const RSA *rsa));
+*/
+// llgo:link (*RSA_METHOD).SetSign C.RSA_meth_set_sign
+func (*RSA_METHOD) SetSign(sign func(
+	typ c.Int, msg *byte, mlen c.Uint,
+	sigret *byte, siglen *c.Uint, rsa *RSA) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_verify(RSA_METHOD *rsa,
+                        int (*verify) (int dtype, const unsigned char *m,
+                                       unsigned int m_length,
+                                       const unsigned char *sigbuf,
+                                       unsigned int siglen, const RSA *rsa));
+*/
+// llgo:link (*RSA_METHOD).SetVerify C.RSA_meth_set_verify
+func (*RSA_METHOD) SetVerify(verify func(
+	dtype c.Int, msg *byte, mlen c.Uint,
+	sigbuf *byte, siglen c.Uint, rsa *RSA) c.Int) c.Int {
+	return 0
+}
+
+/*
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_keygen(RSA_METHOD *rsa,
+                        int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
+                                       BN_GENCB *cb));
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth,
+                                    int (*keygen) (RSA *rsa, int bits,
+                                                   int primes, BIGNUM *e,
+                                                   BN_GENCB *cb));
+*/
+
+// -----------------------------------------------------------------------------
+
+type RSA struct {
+	Unused [0]byte
+}
+
+// OSSL_DEPRECATEDIN_3_0 RSA *RSA_new(void);
+//
+//go:linkname RSANew C.RSA_new
+func RSANew() *RSA
+
+// OSSL_DEPRECATEDIN_3_0 RSA *RSA_new_method(ENGINE *engine);
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_free(RSA *r);
+//
+// llgo:link (*RSA).Free C.RSA_free
+func (*RSA) Free() {}
+
+// "up" the RSA object's reference count
+// OSSL_DEPRECATEDIN_3_0 int RSA_up_ref(RSA *r);
+//
+// llgo:link (*RSA).UpRef C.RSA_up_ref
+func (*RSA) UpRef() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_bits(const RSA *rsa);
+//
+// llgo:link (*RSA).Bits C.RSA_bits
+func (*RSA) Bits() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_size(const RSA *rsa);
+//
+// llgo:link (*RSA).Size C.RSA_size
+func (*RSA) Size() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_security_bits(const RSA *rsa);
+//
+// llgo:link (*RSA).SecurityBits C.RSA_security_bits
+func (*RSA) SecurityBits() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_flags(const RSA *r);
+//
+// llgo:link (*RSA).Flags C.RSA_flags
+func (*RSA) Flags() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_set_flags(RSA *r, int flags);
+//
+// llgo:link (*RSA).SetFlags C.RSA_set_flags
+func (*RSA) SetFlags(flags c.Int) {}
+
+// OSSL_DEPRECATEDIN_3_0 void RSA_clear_flags(RSA *r, int flags);
+//
+// llgo:link (*RSA).ClearFlags C.RSA_clear_flags
+func (*RSA) ClearFlags(flags c.Int) {}
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_test_flags(const RSA *r, int flags);
+//
+// llgo:link (*RSA).TestFlags C.RSA_test_flags
+func (*RSA) TestFlags(flags c.Int) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_get_version(RSA *r);
+//
+// llgo:link (*RSA).GetVersion C.RSA_get_version
+func (*RSA) GetVersion() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_set_ex_data(RSA *r, int idx, void *arg);
+//
+// llgo:link (*RSA).SetExData C.RSA_set_ex_data
+func (*RSA) SetExData(idx c.Int, arg unsafe.Pointer) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 void *RSA_get_ex_data(const RSA *r, int idx);
+//
+// llgo:link (*RSA).GetExData C.RSA_get_ex_data
+func (*RSA) GetExData(idx c.Int) unsafe.Pointer { return nil }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
+//
+// llgo:link (*RSA).SetMethod C.RSA_set_method
+func (*RSA) SetMethod(meth *RSA_METHOD) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
+//
+// llgo:link (*RSA).GenerateKeyEx C.RSA_generate_key_ex
+func (*RSA) GenerateKeyEx(bits c.Int, e *BIGNUM, cb *BN_GENCB) c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes, BIGNUM *e, BN_GENCB *cb);
+//
+// llgo:link (*RSA).GenerateMultiPrimeKey C.RSA_generate_multi_prime_key
+func (*RSA) GenerateMultiPrimeKey(bits, primes c.Int, e *BIGNUM, cb *BN_GENCB) c.Int { return 0 }
+
+/*
+// next 4 return -1 on error
+
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+OSSL_DEPRECATEDIN_3_0
+int RSA_private_decrypt(int flen, const unsigned char *from, unsigned char *to,
+						RSA *rsa, int padding);
+*/
+//go:linkname RSAPublicEncrypt C.RSA_public_encrypt
+func RSAPublicEncrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPrivateEncrypt C.RSA_private_encrypt
+func RSAPrivateEncrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPublicDecrypt C.RSA_public_decrypt
+func RSAPublicDecrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+//go:linkname RSAPrivateDecrypt C.RSA_private_decrypt
+func RSAPrivateDecrypt(flen c.Int, from *byte, to *byte, rsa *RSA, padding c.Int) c.Int
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_sign(
+// int type, const unsigned char *m, unsigned int m_length,
+// unsigned char *sigret, unsigned int *siglen, RSA *rsa);
+//
+//go:linkname RSASign C.RSA_sign
+func RSASign(typ c.Int, msg *byte, mlen c.Uint, sigret *byte, siglen *c.Uint, rsa *RSA) c.Int
+
+// OSSL_DEPRECATEDIN_3_0 int RSA_verify(int type, const unsigned char *m,
+//	  unsigned int m_length,
+//	  const unsigned char *sigbuf,
+//	  unsigned int siglen, RSA *rsa);
+
+// -----------------------------------------------------------------------------

c/openssl/sha1.go

@@ -0,0 +1,94 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	SHA_DIGEST_LENGTH = 20
+	SHA_LBLOCK        = 16
+	SHA_CBLOCK        = (SHA_LBLOCK * 4)
+	SHA_LAST_BLOCK    = (SHA_CBLOCK - 8)
+
+	SHA256_CBLOCK            = (SHA_LBLOCK * 4)
+	SHA256_192_DIGEST_LENGTH = 24
+	SHA224_DIGEST_LENGTH     = 28
+	SHA256_DIGEST_LENGTH     = 32
+	SHA384_DIGEST_LENGTH     = 48
+	SHA512_DIGEST_LENGTH     = 64
+	SHA512_CBLOCK            = (SHA_LBLOCK * 8)
+)
+
+type SHA_LONG64 = c.UlongLong
+
+type SHA_LONG = c.Uint
+
+type SHA_CTX struct {
+	H0, H1, H2, H3, H4 SHA_LONG
+	Nl, Nh             SHA_LONG
+	Data               [SHA_LBLOCK]SHA_LONG
+	Num                c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
+//
+// llgo:link (*SHA_CTX).Init C.SHA1_Init
+func (c *SHA_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA_CTX).Update C.SHA1_Update
+func (c *SHA_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
+//
+//go:linkname sha1Final C.SHA1_Final
+func sha1Final(md *byte, c *SHA_CTX) c.Int
+
+func (c *SHA_CTX) Final(md *byte) c.Int {
+	return sha1Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA_CTX).Transform C.SHA1_Transform
+func (c *SHA_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA1 C.SHA1
+func SHA1(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA1Bytes(data []byte, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA1String(data string, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/openssl/sha256.go

@@ -0,0 +1,117 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA256_CTX struct {
+	H          [8]SHA_LONG
+	Nl, Nh     SHA_LONG
+	Data       [SHA_LBLOCK]SHA_LONG
+	Num, MdLen c.Uint
+}
+
+type SHA224_CTX SHA256_CTX
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA224_CTX).Init C.SHA224_Init
+func (c *SHA224_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA224_CTX).Update C.SHA224_Update
+func (c *SHA224_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA224_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA224_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha224Final C.SHA224_Final
+func sha224Final(md *byte, c *SHA224_CTX) c.Int
+
+func (c *SHA224_CTX) Final(md *byte) c.Int {
+	return sha224Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA256_CTX).Init C.SHA256_Init
+func (c *SHA256_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA256_CTX).Update C.SHA256_Update
+func (c *SHA256_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA256_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA256_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha256Final C.SHA256_Final
+func sha256Final(md *byte, c *SHA256_CTX) c.Int
+
+func (c *SHA256_CTX) Final(md *byte) c.Int {
+	return sha256Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA256_CTX).Transform C.SHA256_Transform
+func (c *SHA256_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA224 C.SHA224
+func SHA224(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA224Bytes(data []byte, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA224String(data string, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA256 C.SHA256
+func SHA256(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA256Bytes(data []byte, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA256String(data string, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/openssl/sha512.go

@@ -0,0 +1,115 @@
+/*
+ * 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 openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA512_CTX struct {
+	H          [8]SHA_LONG64
+	N1, Nh     SHA_LONG64
+	D          [SHA_LBLOCK]SHA_LONG64
+	Num, MdLen c.Uint
+}
+
+type SHA384_CTX SHA512_CTX
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA384_CTX).Init C.SHA384_Init
+func (c *SHA384_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA384_CTX).Update C.SHA384_Update
+func (c *SHA384_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA384_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA384_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha384Final C.SHA384_Final
+func sha384Final(md *byte, c *SHA384_CTX) c.Int
+
+func (c *SHA384_CTX) Final(md *byte) c.Int {
+	return sha384Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA512_CTX).Init C.SHA512_Init
+func (c *SHA512_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA512_CTX).Update C.SHA512_Update
+func (c *SHA512_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+func (c *SHA512_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+func (c *SHA512_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha512Final C.SHA512_Final
+func sha512Final(md *byte, c *SHA512_CTX) c.Int
+
+func (c *SHA512_CTX) Final(md *byte) c.Int {
+	return sha512Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
+//
+// llgo:link (*SHA512_CTX).Transform C.SHA512_Transform
+func (c *SHA512_CTX) Transform(data *byte) {}
+
+// unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA384 C.SHA384
+func SHA384(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA384Bytes(data []byte, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA384String(data string, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA512 C.SHA512
+func SHA512(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA512Bytes(data []byte, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA512String(data string, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}

c/os/_os/os.c

@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+int llgoClearenv() {
+	extern char **environ;
+	if (environ != NULL) {
+		*environ = NULL;
+	}
+	return 0;
+}

c/os/os.go

@@ -27,10 +27,6 @@ import (
 	"github.com/goplus/llgo/c/syscall"
 )
 
-const (
-	LLGoPackage = "decl"
-)
-
 const (
 	PATH_MAX = C.PATH_MAX
 )
@@ -58,6 +54,10 @@ const (
 	O_TRUNC = 0x00000400
 )
 
+const (
+	EAGAIN = 35
+)
+
 type (
 	ModeT C.mode_t
 	UidT  C.uid_t
@@ -146,9 +146,6 @@ func Putenv(env *c.Char) c.Int
 //go:linkname Unsetenv C.unsetenv
 func Unsetenv(name *c.Char) c.Int
 
-//go:linkname Clearenv C.clearenv
-func Clearenv()
-
 // -----------------------------------------------------------------------------
 
 //go:linkname Fchdir C.fchdir

c/os/os_linux.go

@@ -0,0 +1,28 @@
+//go:build linux
+
+/*
+ * 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 os
+
+import "C"
+
+const (
+	LLGoPackage = "decl"
+)
+
+//go:linkname Clearenv C.clearenv
+func Clearenv()

c/os/os_other.go

@@ -0,0 +1,29 @@
+//go:build !linux
+
+/*
+ * 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 os
+
+import "C"
+
+const (
+	LLGoFiles   = "_os/os.c"
+	LLGoPackage = "link"
+)
+
+//go:linkname Clearenv C.llgoClearenv
+func Clearenv()

c/pthread/sync/_pthd/pthd.c

@@ -5,3 +5,15 @@
 pthread_once_t llgoSyncOnceInitVal = PTHREAD_ONCE_INIT;
 
 // -----------------------------------------------------------------------------
+
+// wrap return type to void
+void wrap_pthread_mutex_lock(pthread_mutex_t *mutex) {
+    pthread_mutex_lock(mutex);
+}
+
+// wrap return type to void
+void wrap_pthread_mutex_unlock(pthread_mutex_t *mutex) {
+    pthread_mutex_unlock(mutex);
+}
+
+// -----------------------------------------------------------------------------

c/pthread/sync/sync.go

@@ -76,13 +76,13 @@ func (m *Mutex) Init(attr *MutexAttr) c.Int { return 0 }
 // llgo:link (*Mutex).Destroy C.pthread_mutex_destroy
 func (m *Mutex) Destroy() {}
 
-// llgo:link (*Mutex).Lock C.pthread_mutex_lock
-func (m *Mutex) Lock() {}
-
 // llgo:link (*Mutex).TryLock C.pthread_mutex_trylock
 func (m *Mutex) TryLock() c.Int { return 0 }
 
-// llgo:link (*Mutex).Unlock C.pthread_mutex_unlock
+// llgo:link (*Mutex).Lock C.wrap_pthread_mutex_lock
+func (m *Mutex) Lock() {}
+
+// llgo:link (*Mutex).Unlock C.wrap_pthread_mutex_unlock
 func (m *Mutex) Unlock() {}
 
 // -----------------------------------------------------------------------------

c/setjmp/setjmp.go

@@ -44,9 +44,6 @@ func Longjmp(env *JmpBuf, val c.Int)
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Sigsetjmp C.sigsetjmp
-func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int
-
 //go:linkname Siglongjmp C.siglongjmp
 func Siglongjmp(env *SigjmpBuf, val c.Int)
 

c/setjmp/setjmp_linux.go

@@ -0,0 +1,12 @@
+//go:build linux
+
+package setjmp
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+//go:linkname Sigsetjmp C.__sigsetjmp
+func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int

c/setjmp/setjmp_other.go

@@ -0,0 +1,12 @@
+//go:build !linux
+
+package setjmp
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+//go:linkname Sigsetjmp C.sigsetjmp
+func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int

c/sys/_demo/selectdemo/select.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/llgo/c/sys"
+)
+
+func main() {
+	var readFds sys.FdSet
+	sys.FD_ZERO(&readFds)
+	sys.FD_SET(0, &readFds)
+
+	var tv sys.Timeval
+	tv.Sec = 5
+	tv.Usec = 0
+
+	c.Printf(c.Str("Waiting for input on stdin...\n"))
+	ret := sys.Select(1, &readFds, nil, nil, &tv)
+	if ret == -1 {
+		c.Perror(c.Str("select error"))
+		c.Exit(1)
+	} else if ret == 0 {
+		c.Printf(c.Str("Timeout occurred! No data after 5 seconds.\n"))
+	} else {
+		if sys.FD_ISSET(0, &readFds) != 0 {
+			var buffer [100]c.Char
+			n := os.Read(0, c.Pointer(&buffer[:][0]), unsafe.Sizeof(buffer)-1)
+			if n == -1 {
+				c.Perror(c.Str("read error"))
+				c.Exit(1)
+			} else if n == 0 {
+				c.Printf(c.Str("End of file\n"))
+			} else {
+				buffer[n] = c.Char(0)
+				c.Printf(c.Str("Read %ld bytes: %s\n"), n, &buffer[0])
+			}
+		}
+	}
+}

c/sys/_demo/selectdemo2/select2.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/net"
+	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/llgo/c/sys"
+)
+
+const (
+	SERVER_IP   = "110.242.68.66" // Get the IP address by ping baidu.com
+	SERVER_PORT = 80
+	BUFFER_SIZE = 4096 * 1024
+)
+
+func main() {
+	var server net.SockaddrIn
+
+	sendBuf := c.Str("GET / HTTP/1.1\r\nHost: baidu.com\r\n\r\n")
+	var recvBuf [BUFFER_SIZE]c.Char
+	var bytes_sent, bytes_received c.Int
+
+	// create net
+	sock := net.Socket(net.AF_INET, net.SOCK_STREAM, 0)
+	if sock < 0 {
+		c.Perror(c.Str("Socket creation failed"))
+		return
+	}
+
+	// set server addr
+	c.Memset(c.Pointer(&server), 0, unsafe.Sizeof(server))
+	server.Family = net.AF_INET
+	server.Port = net.Htons(SERVER_PORT)
+	server.Addr.Addr = net.InetAddr(c.Str(SERVER_IP))
+
+	// connect to server
+	if net.Connect(sock, (*net.SockAddr)(c.Pointer(&server)), c.Uint(unsafe.Sizeof(server))) < 0 {
+		c.Perror(c.Str("Connect failed"))
+		return
+	}
+
+	var writefds, readfds sys.FdSet
+	var timeout sys.Timeval
+
+	//  Monitor socket writes
+	sys.FD_ZERO(&writefds)
+	sys.FD_SET(sock, &writefds)
+	timeout.Sec = 10
+	timeout.Usec = 0
+
+	// Use select to monitor the readiness of writes
+	if sys.Select(sock+1, nil, &writefds, nil, &timeout) > 0 {
+		if sys.FD_ISSET(sock, &writefds) != 0 {
+			bytes_sent = c.Int(net.Send(sock, c.Pointer(sendBuf), c.Strlen(sendBuf), 0))
+			if bytes_sent < 0 {
+				c.Perror(c.Str("send failed"))
+				return
+			}
+		}
+	} else {
+		c.Perror(c.Str("Select write error"))
+		return
+	}
+
+	// Monitor socket reads
+	sys.FD_ZERO(&readfds)
+	sys.FD_SET(sock, &readfds)
+
+	// Use select to monitor the readiness of the read operation
+	if sys.Select(sock+1, &readfds, nil, nil, &timeout) > 0 {
+		if sys.FD_ISSET(sock, &writefds) != -1 {
+			bytes_received = c.Int(net.Recv(sock, c.Pointer(&recvBuf[:][0]), BUFFER_SIZE-1, 0))
+			if bytes_received < 0 {
+				c.Perror(c.Str("receive failed"))
+				return
+			}
+			recvBuf[bytes_received] = c.Char(0)
+			c.Printf(c.Str("Received:\n%s\n"), &recvBuf[0])
+		}
+	} else {
+		c.Perror(c.Str("Select read error"))
+		return
+	}
+
+	os.Close(sock)
+}

c/sys/_wrap/fddef.c

@@ -0,0 +1,13 @@
+#include <sys/types.h>
+
+int llgo_FD_ISSET(int n, fd_set *fd) {
+    return FD_ISSET(n, fd);
+}
+
+void llgo_FD_SET(int n, fd_set *fd) {
+    FD_SET(n, fd);
+}
+
+void llgo_FD_ZERO(fd_set *fd) {
+    FD_ZERO(fd);
+}

c/sys/select.go

@@ -0,0 +1,34 @@
+package sys
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/syscall"
+)
+
+const (
+	LLGoFiles   = "_wrap/fddef.c"
+	LLGoPackage = "link"
+)
+
+// -----------------------------------------------------------------------------
+
+type (
+	FdSet   = syscall.FdSet
+	Timeval = syscall.Timeval
+)
+
+//go:linkname FD_ZERO C.llgo_FD_ZERO
+func FD_ZERO(fds *FdSet)
+
+//go:linkname FD_SET C.llgo_FD_SET
+func FD_SET(fd c.Int, fds *FdSet)
+
+//go:linkname FD_ISSET C.llgo_FD_ISSET
+func FD_ISSET(fd c.Int, fds *FdSet) c.Int
+
+//go:linkname Select C.select
+func Select(n c.Int, fdsRead, fdsWrite, fdsError *FdSet, timeout *Timeval) c.Int
+
+// -----------------------------------------------------------------------------

c/syscall/syscall.go

@@ -17,7 +17,7 @@
 package syscall
 
 const (
-	LLGoPackage = "decl"
+	LLGoPackage = "noinit"
 )
 
 type Errno = uintptr
@@ -25,3 +25,8 @@ type Errno = uintptr
 // A Signal is a number describing a process signal.
 // It implements the os.Signal interface.
 type Signal = int
+
+// Unix returns the time stored in ts as seconds plus nanoseconds.
+func (ts *Timespec) Unix() (sec int64, nsec int64) {
+	return int64(ts.Sec), int64(ts.Nsec)
+}

c/zlib/_demo/crc32demo/crc.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/goplus/llgo/c/zlib"
+)
+
+func main() {
+	fmt.Printf("%08x\n", zlib.Crc32ZString(0, "Hello world"))
+}

c/zlib/zlib.go

@@ -17,7 +17,7 @@
 package zlib
 
 import (
-	_ "unsafe"
+	"unsafe"
 
 	"github.com/goplus/llgo/c"
 )
@@ -76,17 +76,185 @@ const (
 	DEFLATED = 8
 )
 
+// -----------------------------------------------------------------------------
+
+/*
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+
+compressBound() returns an upper bound on the compressed size after
+compress() or compress2() on sourceLen bytes.  It would be used before a
+compress() or compress2() call to allocate the destination buffer.
+*/
 //go:linkname CompressBound C.compressBound
 func CompressBound(sourceLen c.Ulong) c.Ulong
 
+/*
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen));
+
+Compresses the source buffer into the destination buffer.  sourceLen is
+the byte length of the source buffer.  Upon entry, destLen is the total size
+of the destination buffer, which must be at least the value returned by
+compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+compressed data.  compress() is equivalent to compress2() with a level
+parameter of Z_DEFAULT_COMPRESSION.
+
+compress returns Z_OK if success, Z_MEM_ERROR if there was not
+enough memory, Z_BUF_ERROR if there was not enough room in the output
+buffer.
+*/
 //go:linkname Compress C.compress
 func Compress(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong) c.Int
 
+/*
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen, int level));
+
+Compresses the source buffer into the destination buffer.  The level
+parameter has the same meaning as in deflateInit.  sourceLen is the byte
+length of the source buffer.  Upon entry, destLen is the total size of the
+destination buffer, which must be at least the value returned by
+compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+compressed data.
+
+compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+Z_STREAM_ERROR if the level parameter is invalid.
+*/
 //go:linkname Compress2 C.compress2
 func Compress2(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong, level c.Int) c.Int
 
+/*
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong sourceLen));
+
+Decompresses the source buffer into the destination buffer.  sourceLen is
+the byte length of the source buffer.  Upon entry, destLen is the total size
+of the destination buffer, which must be large enough to hold the entire
+uncompressed data.  (The size of the uncompressed data must have been saved
+previously by the compressor and transmitted to the decompressor by some
+mechanism outside the scope of this compression library.) Upon exit, destLen
+is the actual size of the uncompressed data.
+
+uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+enough memory, Z_BUF_ERROR if there was not enough room in the output
+buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.  In
+the case where there is not enough room, uncompress() will fill the output
+buffer with the uncompressed data up to that point.
+*/
 //go:linkname Uncompress C.uncompress
 func Uncompress(dest *byte, destLen *c.Ulong, source *byte, sourceLen c.Ulong) c.Int
 
+/*
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest,   uLongf *destLen,
+	const Bytef *source, uLong *sourceLen));
+
+Same as uncompress, except that sourceLen is a pointer, where the
+length of the source is *sourceLen.  On return, *sourceLen is the number of
+source bytes consumed.
+*/
 //go:linkname Uncompress2 C.uncompress2
 func Uncompress2(dest *byte, destLen *c.Ulong, source *byte, sourceLen *c.Ulong) c.Int
+
+// -----------------------------------------------------------------------------
+
+/*
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+
+Update a running CRC-32 with the bytes buf[0..len-1] and return the
+updated CRC-32.  If buf is Z_NULL, this function returns the required
+initial value for the crc.  Pre- and post-conditioning (one's complement) is
+performed within this function so it shouldn't be done by the application.
+
+Usage example:
+
+	uLong crc = crc32(0L, Z_NULL, 0);
+
+	while (read_buffer(buffer, length) != EOF) {
+	crc = crc32(crc, buffer, length);
+	}
+	if (crc != original_crc) error();
+*/
+//go:linkname Crc32 C.crc32
+func Crc32(crc c.Ulong, buf *byte, len c.Uint) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf, z_size_t len));
+
+Same as crc32(), but with a size_t length.
+*/
+//go:linkname Crc32Z C.crc32_z
+func Crc32Z(crc c.Ulong, buf *byte, len uintptr) c.Ulong
+
+func Crc32ZBytes(crc c.Ulong, buf []byte) c.Ulong {
+	return Crc32Z(crc, unsafe.SliceData(buf), uintptr(len(buf)))
+}
+
+func Crc32ZString(crc c.Ulong, buf string) c.Ulong {
+	return Crc32Z(crc, unsafe.StringData(buf), uintptr(len(buf)))
+}
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+Combine two CRC-32 check values into one.  For two sequences of bytes,
+seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+len2.
+*/
+//go:linkname Crc32Combine C.crc32_combine
+func Crc32Combine(crc1 c.Ulong, crc2 c.Ulong, len2 int64) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+return the updated checksum.  If buf is Z_NULL, this function returns the
+required initial value for the checksum.
+
+An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
+much faster.
+
+Usage example:
+
+	uLong adler = adler32(0L, Z_NULL, 0);
+
+	while (read_buffer(buffer, length) != EOF) {
+	adler = adler32(adler, buffer, length);
+	}
+	if (adler != original_adler) error();
+*/
+//go:linkname Adler32 C.adler32
+func Adler32(adler c.Ulong, buf *byte, len c.Uint) c.Ulong
+
+/*
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, z_size_t len));
+
+Same as adler32(), but with a size_t length.
+*/
+//go:linkname Adler32Z C.adler32_z
+func Adler32Z(adler c.Ulong, buf *byte, len uintptr) c.Ulong
+
+func Adler32ZBytes(adler c.Ulong, buf []byte) c.Ulong {
+	return Adler32Z(adler, unsafe.SliceData(buf), uintptr(len(buf)))
+}
+
+func Adler32ZString(adler c.Ulong, buf string) c.Ulong {
+	return Adler32Z(adler, unsafe.StringData(buf), uintptr(len(buf)))
+}
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, z_off_t len2));
+
+Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.  Note
+that the z_off_t type (like off_t) is a signed integer.  If len2 is
+negative, the result has no meaning or utility.
+*/
+//go:linkname Adler32Combine C.adler32_combine
+func Adler32Combine(adler1 c.Ulong, adler2 c.Ulong, len2 int64) c.Ulong
+
+// -----------------------------------------------------------------------------

chore/_xtool/castdump/castdump.go

@@ -0,0 +1,217 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/clang"
+)
+
+type Data struct {
+	Depth c.Uint
+	Unit  *clang.TranslationUnit
+}
+
+var accessMap = map[clang.CXXAccessSpecifier]string{
+	clang.CXXInvalidAccessSpecifier: "invalid",
+	clang.CXXPublic:                 "public",
+	clang.CXXProtected:              "protected",
+	clang.CXXPrivate:                "private",
+}
+
+func printIndent(depth c.Uint) {
+	fmt.Print(strings.Repeat("   ", int(depth)))
+}
+
+func accessToString(spec clang.CXXAccessSpecifier) string {
+	if str, ok := accessMap[spec]; ok {
+		return str
+	}
+	return "unknown"
+}
+
+func visit(cursor, parent clang.Cursor, ClientData c.Pointer) clang.ChildVisitResult {
+	data := (*Data)(ClientData)
+	printAST(cursor, data)
+	return clang.ChildVisit_Continue
+}
+
+func printType(t clang.Type, data *Data) {
+	printIndent(data.Depth)
+
+	typeSpell := t.String()
+	typeKind := t.Kind.String()
+
+	if t.Kind == clang.TypeInvalid {
+	} else if t.Kind == clang.TypeUnexposed {
+		c.Printf(c.Str("<UnexposedType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
+	} else if t.Kind >= clang.TypeFirstBuiltin && t.Kind <= clang.TypeLastBuiltin {
+		c.Printf(c.Str("<BuiltinType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
+	} else if t.Kind > clang.TypeComplex {
+		c.Printf(c.Str("<ComplexType|%s>: %s\n"), typeKind.CStr(), typeSpell.CStr())
+	}
+
+	data.Depth++
+	switch t.Kind {
+	case clang.TypePointer:
+		printType(t.PointeeType(), data)
+	case clang.TypeIncompleteArray, clang.TypeVariableArray, clang.TypeDependentSizedArray, clang.TypeConstantArray:
+		printType(t.ArrayElementType(), data)
+	case clang.TypeTypedef:
+		printType(t.CanonicalType(), data)
+	case clang.TypeFunctionProto:
+		printType(t.ResultType(), data)
+		for i := 0; i < int(t.NumArgTypes()); i++ {
+			printType(t.ArgType(c.Uint(i)), data)
+		}
+	}
+	data.Depth--
+
+	typeKind.Dispose()
+	typeSpell.Dispose()
+}
+
+func printLocation(cursor clang.Cursor) {
+	loc := cursor.Location()
+	var file clang.File
+	var line, column c.Uint
+
+	loc.SpellingLocation(&file, &line, &column, nil)
+	filename := file.FileName()
+	defer filename.Dispose()
+
+	c.Printf(c.Str("(Loc:%s:%d:%d)\n"), filename.CStr(), line, column)
+}
+
+func printAccess(cursor clang.Cursor) {
+	kind := cursor.Kind.String()
+	spell := cursor.String()
+	defer kind.Dispose()
+	defer spell.Dispose()
+
+	c.Printf(c.Str("%s: %s %s"), kind.CStr(), spell.CStr(), c.AllocaCStr(accessToString(cursor.CXXAccessSpecifier())))
+	printLocation(cursor)
+}
+
+func printMacro(cursor clang.Cursor, unit *clang.TranslationUnit) {
+	kind := cursor.Kind.String()
+	defer kind.Dispose()
+
+	c.Printf(c.Str("%s: "), kind.CStr())
+	ran := cursor.Extent()
+	var numTokens c.Uint
+	var tokens *clang.Token
+	unit.Tokenize(ran, &tokens, &numTokens)
+	tokensSlice := unsafe.Slice(tokens, int(numTokens))
+	for _, tok := range tokensSlice {
+		tokStr := unit.Token(tok)
+		c.Printf(c.Str("%s "), tokStr.CStr())
+		tokStr.Dispose()
+	}
+	printLocation(cursor)
+}
+
+func printFunc(cursor clang.Cursor, data *Data) {
+	kind := cursor.Kind.String()
+	spell := cursor.String()
+	symbol := cursor.Mangling()
+	defer symbol.Dispose()
+	defer kind.Dispose()
+	defer spell.Dispose()
+
+	c.Printf(c.Str("%s: %s (Symbol: %s)"), kind.CStr(), spell.CStr(), symbol.CStr())
+	printLocation(cursor)
+	printType(cursor.Type(), data)
+}
+
+func printEnumConstant(cursor clang.Cursor) {
+	kind := cursor.Kind.String()
+	spell := cursor.String()
+	defer kind.Dispose()
+	defer spell.Dispose()
+
+	c.Printf(c.Str("%s: %s:%lld"), kind.CStr(), spell.CStr(), cursor.EnumConstantDeclValue())
+	printLocation(cursor)
+}
+
+func printDefault(cursor clang.Cursor, data *Data) {
+	kind := cursor.Kind.String()
+	spell := cursor.String()
+	defer kind.Dispose()
+	defer spell.Dispose()
+
+	// node which has type
+	if cursor.Type().Kind != clang.TypeInvalid {
+		c.Printf(c.Str("%s: %s"), kind.CStr(), spell.CStr())
+		printLocation(cursor)
+		printType(cursor.Type(), data)
+	} else {
+		c.Printf(c.Str("%s: %s\n"), kind.CStr(), spell.CStr())
+	}
+}
+
+func printAST(cursor clang.Cursor, data *Data) {
+	kind := cursor.Kind.String()
+	spell := cursor.String()
+
+	printIndent(data.Depth)
+
+	switch cursor.Kind {
+	case clang.CursorCXXAccessSpecifier:
+		printAccess(cursor)
+	case clang.CursorMacroDefinition:
+		printMacro(cursor, data.Unit)
+	case clang.CursorFunctionDecl, clang.CursorCXXMethod, clang.CursorConstructor, clang.CursorDestructor:
+		printFunc(cursor, data)
+	case clang.CursorEnumConstantDecl:
+		printEnumConstant(cursor)
+	default:
+		printDefault(cursor, data)
+	}
+
+	data.Depth++
+	clang.VisitChildren(cursor, visit, c.Pointer(data))
+	data.Depth--
+
+	kind.Dispose()
+	spell.Dispose()
+}
+
+func main() {
+	if c.Argc != 2 {
+		fmt.Fprintln(os.Stderr, "Usage: castdump <headerFile>")
+		return
+	}
+
+	args := make([]*c.Char, 3)
+	args[0] = c.Str("-x")
+	args[1] = c.Str("c++")
+	args[2] = c.Str("-std=c++11")
+
+	sourceFile := *c.Advance(c.Argv, 1)
+	index := clang.CreateIndex(0, 0)
+	unit := index.ParseTranslationUnit(
+		sourceFile,
+		unsafe.SliceData(args), 3,
+		nil, 0,
+		clang.DetailedPreprocessingRecord,
+	)
+	defer index.Dispose()
+	defer unit.Dispose()
+
+	if unit == nil {
+		println("Unable to parse translation unit. Quitting.")
+		c.Exit(1)
+	}
+
+	cursor := unit.Cursor()
+
+	Data := &Data{
+		Depth: 0,
+		Unit:  unit,
+	}
+	printAST(cursor, Data)
+}

chore/_xtool/llcppsigfetch/llcppsigfetch.go

@@ -0,0 +1,21 @@
+/*
+ * 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 main
+
+func main() {
+	// TODO(xsw): implement llcppsigfetch tool
+}

chore/_xtool/llcppsymg/config/config.go

@@ -0,0 +1,60 @@
+package config
+
+import (
+	"errors"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/cjson"
+	"github.com/goplus/llgo/chore/llcppg/types"
+)
+
+type Conf struct {
+	*cjson.JSON
+	*types.Config
+}
+
+func GetConf(data []byte) (Conf, error) {
+	parsedConf := cjson.ParseBytes(data)
+	if parsedConf == nil {
+		return Conf{}, errors.New("failed to parse config")
+	}
+
+	config := &types.Config{
+		Name:         GetStringItem(parsedConf, "name", ""),
+		CFlags:       GetStringItem(parsedConf, "cflags", ""),
+		Libs:         GetStringItem(parsedConf, "libs", ""),
+		Include:      GetStringArrayItem(parsedConf, "include"),
+		TrimPrefixes: GetStringArrayItem(parsedConf, "trimPrefixes"),
+	}
+
+	return Conf{
+		JSON:   parsedConf,
+		Config: config,
+	}, nil
+}
+
+func GetString(obj *cjson.JSON) (value string) {
+	str := obj.GetStringValue()
+	return unsafe.String((*byte)(unsafe.Pointer(str)), c.Strlen(str))
+}
+
+func GetStringItem(obj *cjson.JSON, key string, defval string) (value string) {
+	item := obj.GetObjectItemCaseSensitive(c.AllocaCStr(key))
+	if item == nil {
+		return defval
+	}
+	return GetString(item)
+}
+
+func GetStringArrayItem(obj *cjson.JSON, key string) (value []string) {
+	item := obj.GetObjectItemCaseSensitive(c.AllocaCStr(key))
+	if item == nil {
+		return
+	}
+	value = make([]string, item.GetArraySize())
+	for i := range value {
+		value[i] = GetString(item.GetArrayItem(c.Int(i)))
+	}
+	return
+}

chore/_xtool/llcppsymg/llcppsymg.go

@@ -0,0 +1,233 @@
+/*
+ * 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 main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/cjson"
+	"github.com/goplus/llgo/chore/_xtool/llcppsymg/config"
+	"github.com/goplus/llgo/chore/_xtool/llcppsymg/parse"
+	"github.com/goplus/llgo/chore/llcppg/types"
+	"github.com/goplus/llgo/cpp/llvm"
+	"github.com/goplus/llgo/xtool/nm"
+)
+
+func main() {
+	cfgFile := "llcppg.cfg"
+	if len(os.Args) > 1 {
+		cfgFile = os.Args[1]
+	}
+
+	var data []byte
+	var err error
+	if cfgFile == "-" {
+		data, err = io.ReadAll(os.Stdin)
+	} else {
+		data, err = os.ReadFile(cfgFile)
+	}
+	check(err)
+
+	conf, err := config.GetConf(data)
+	check(err)
+	defer conf.Delete()
+
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to parse config file:", cfgFile)
+	}
+	symbols, err := parseDylibSymbols(conf.Libs)
+
+	check(err)
+
+	filepaths := genHeaderFilePath(conf.CFlags, conf.Include)
+	headerInfos, err := parse.ParseHeaderFile(filepaths, conf.TrimPrefixes)
+	check(err)
+
+	symbolInfo := getCommonSymbols(symbols, headerInfos, conf.TrimPrefixes)
+
+	err = genSymbolTableFile(symbolInfo)
+	check(err)
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func parseDylibSymbols(lib string) ([]*nm.Symbol, error) {
+	dylibPath, err := genDylibPath(lib)
+	if err != nil {
+		return nil, errors.New("failed to generate dylib path")
+	}
+
+	files, err := nm.New("").List(dylibPath)
+	if err != nil {
+		return nil, errors.New("failed to list symbols in dylib")
+	}
+
+	var symbols []*nm.Symbol
+	for _, file := range files {
+		symbols = append(symbols, file.Symbols...)
+	}
+
+	return symbols, nil
+}
+
+func genDylibPath(lib string) (string, error) {
+	output := lib
+	libPath := ""
+	libName := ""
+	for _, part := range strings.Fields(string(output)) {
+		if strings.HasPrefix(part, "-L") {
+			libPath = part[2:]
+		} else if strings.HasPrefix(part, "-l") {
+			libName = part[2:]
+		}
+	}
+
+	if libPath == "" || libName == "" {
+		return "", fmt.Errorf("failed to parse pkg-config output: %s", output)
+	}
+
+	dylibPath := filepath.Join(libPath, "lib"+libName+".dylib")
+	return dylibPath, nil
+}
+
+func decodeSymbol(symbolName string) string {
+	if symbolName == "" {
+		return ""
+	}
+	demangled := llvm.ItaniumDemangle(symbolName, true)
+	if demangled == nil {
+		return symbolName
+	}
+	defer c.Free(unsafe.Pointer(demangled))
+	demangleName := c.GoString(demangled)
+	return strings.TrimSpace(demangleName)
+}
+
+func genHeaderFilePath(cflags string, files []string) []string {
+	prefixPath := cflags
+	prefixPath = strings.TrimPrefix(prefixPath, "-I")
+	var includePaths []string
+	for _, file := range files {
+		includePaths = append(includePaths, filepath.Join(prefixPath, "/"+file))
+	}
+	return includePaths
+}
+
+func getCommonSymbols(dylibSymbols []*nm.Symbol, symbolMap map[string]string, prefix []string) []*types.SymbolInfo {
+	var commonSymbols []*types.SymbolInfo
+	for _, dylibSym := range dylibSymbols {
+		symName := strings.TrimPrefix(dylibSym.Name, "_")
+		if goName, ok := symbolMap[symName]; ok {
+			symbolInfo := &types.SymbolInfo{
+				Mangle: symName,
+				CPP:    decodeSymbol(dylibSym.Name),
+				Go:     goName,
+			}
+			commonSymbols = append(commonSymbols, symbolInfo)
+		}
+	}
+	return commonSymbols
+}
+
+func genSymbolTableFile(symbolInfos []*types.SymbolInfo) error {
+	// keep open follow code block can run successfully
+	for i := range symbolInfos {
+		println("symbol", symbolInfos[i].Go)
+	}
+
+	fileName := "llcppg.symb.json"
+	existingSymbols, err := readExistingSymbolTable(fileName)
+	if err != nil {
+		return err
+	}
+
+	for i := range symbolInfos {
+		if existingSymbol, exists := existingSymbols[symbolInfos[i].Mangle]; exists {
+			symbolInfos[i].Go = existingSymbol.Go
+		}
+	}
+
+	root := cjson.Array()
+	defer root.Delete()
+
+	for _, symbol := range symbolInfos {
+		item := cjson.Object()
+		item.SetItem(c.Str("mangle"), cjson.String(c.AllocaCStr(symbol.Mangle)))
+		item.SetItem(c.Str("c++"), cjson.String(c.AllocaCStr(symbol.CPP)))
+		item.SetItem(c.Str("go"), cjson.String(c.AllocaCStr(symbol.Go)))
+		root.AddItem(item)
+	}
+
+	cStr := root.Print()
+	if cStr == nil {
+		return errors.New("symbol table is empty")
+	}
+	defer c.Free(unsafe.Pointer(cStr))
+
+	data := unsafe.Slice((*byte)(unsafe.Pointer(cStr)), c.Strlen(cStr))
+
+	if err := os.WriteFile(fileName, data, 0644); err != nil {
+		return errors.New("failed to write symbol table file")
+	}
+	return nil
+}
+
+func readExistingSymbolTable(fileName string) (map[string]types.SymbolInfo, error) {
+	existingSymbols := make(map[string]types.SymbolInfo)
+
+	if _, err := os.Stat(fileName); err != nil {
+		return existingSymbols, nil
+	}
+
+	data, err := os.ReadFile(fileName)
+	if err != nil {
+		return nil, errors.New("failed to read symbol table file")
+	}
+
+	parsedJSON := cjson.ParseBytes(data)
+	if parsedJSON == nil {
+		return nil, errors.New("failed to parse JSON")
+	}
+
+	arraySize := parsedJSON.GetArraySize()
+
+	for i := 0; i < int(arraySize); i++ {
+		item := parsedJSON.GetArrayItem(c.Int(i))
+		if item == nil {
+			continue
+		}
+		symbol := types.SymbolInfo{
+			Mangle: config.GetStringItem(item, "mangle", ""),
+			CPP:    config.GetStringItem(item, "c++", ""),
+			Go:     config.GetStringItem(item, "go", ""),
+		}
+		existingSymbols[symbol.Mangle] = symbol
+	}
+
+	return existingSymbols, nil
+}

chore/_xtool/llcppsymg/parse/parse.go

@@ -0,0 +1,167 @@
+package parse
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/clang"
+)
+
+type Context struct {
+	namespaceName string
+	className     string
+	prefixes      []string
+	symbolMap     map[string]string
+	currentFile   string
+	nameCounts    map[string]int
+}
+
+func newContext(prefixes []string) *Context {
+	return &Context{
+		prefixes:   prefixes,
+		symbolMap:  make(map[string]string),
+		nameCounts: make(map[string]int),
+	}
+}
+
+func (c *Context) setNamespaceName(name string) {
+	c.namespaceName = name
+}
+
+func (c *Context) setClassName(name string) {
+	c.className = name
+}
+
+func (c *Context) setCurrentFile(filename string) {
+	c.currentFile = filename
+}
+
+func (c *Context) removePrefix(str string) string {
+	for _, prefix := range c.prefixes {
+		if strings.HasPrefix(str, prefix) {
+			return strings.TrimPrefix(str, prefix)
+		}
+	}
+	return str
+}
+
+func (c *Context) genGoName(name string) string {
+	class := c.removePrefix(c.className)
+	name = c.removePrefix(name)
+
+	var baseName string
+	if class == "" {
+		baseName = name
+	} else {
+		baseName = c.genMethodName(class, name)
+	}
+
+	return c.addSuffix(baseName)
+}
+
+func (c *Context) genMethodName(class, name string) string {
+	prefix := "(*" + class + ")."
+	if class == name {
+		return prefix + "Init"
+	}
+	if name == "~"+class {
+		return prefix + "Dispose"
+	}
+	return prefix + name
+}
+
+func (c *Context) addSuffix(name string) string {
+	c.nameCounts[name]++
+	count := c.nameCounts[name]
+	if count > 1 {
+		return name + "__" + strconv.Itoa(count-1)
+	}
+	return name
+}
+
+var context = newContext([]string{})
+
+func collectFuncInfo(cursor clang.Cursor) {
+	cursorStr := cursor.String()
+	symbol := cursor.Mangling()
+
+	name := c.GoString(cursorStr.CStr())
+	symbolName := c.GoString(symbol.CStr())
+	if len(symbolName) >= 1 && symbolName[0] == '_' {
+		symbolName = symbolName[1:]
+	}
+	defer symbol.Dispose()
+	defer cursorStr.Dispose()
+
+	goName := context.genGoName(name)
+	context.symbolMap[symbolName] = goName
+}
+
+func visit(cursor, parent clang.Cursor, clientData c.Pointer) clang.ChildVisitResult {
+	if cursor.Kind == clang.CursorNamespace {
+		nameStr := cursor.String()
+		defer nameStr.Dispose()
+
+		context.setNamespaceName(c.GoString(nameStr.CStr()))
+		clang.VisitChildren(cursor, visit, nil)
+		context.setNamespaceName("")
+	} else if cursor.Kind == clang.CursorClassDecl {
+		nameStr := cursor.String()
+		defer nameStr.Dispose()
+
+		context.setClassName(c.GoString(nameStr.CStr()))
+		clang.VisitChildren(cursor, visit, nil)
+		context.setClassName("")
+	} else if cursor.Kind == clang.CursorCXXMethod || cursor.Kind == clang.CursorFunctionDecl || cursor.Kind == clang.CursorConstructor || cursor.Kind == clang.CursorDestructor {
+		loc := cursor.Location()
+		var file clang.File
+		var line, column c.Uint
+
+		loc.SpellingLocation(&file, &line, &column, nil)
+		filename := file.FileName()
+
+		if c.Strcmp(filename.CStr(), c.AllocaCStr(context.currentFile)) == 0 {
+			collectFuncInfo(cursor)
+		}
+
+		defer filename.Dispose()
+	}
+
+	return clang.ChildVisit_Continue
+}
+
+func ParseHeaderFile(filepaths []string, prefixes []string) (map[string]string, error) {
+	index := clang.CreateIndex(0, 0)
+	args := make([]*c.Char, 3)
+	args[0] = c.Str("-x")
+	args[1] = c.Str("c++")
+	args[2] = c.Str("-std=c++11")
+	context = newContext(prefixes)
+
+	for _, filename := range filepaths {
+		unit := index.ParseTranslationUnit(
+			c.AllocaCStr(filename),
+			unsafe.SliceData(args), 3,
+			nil, 0,
+			clang.TranslationUnit_None,
+		)
+
+		if unit == nil {
+			return nil, errors.New("Unable to parse translation unit for file " + filename)
+		}
+
+		cursor := unit.Cursor()
+		context.setCurrentFile(filename)
+
+		clang.VisitChildren(cursor, visit, nil)
+
+		unit.Dispose()
+	}
+
+	index.Dispose()
+
+	return context.symbolMap, nil
+}