Merge pull request #687 from xushiwei/q

library syscall: linux fix

.github/workflows/go.yml

@@ -5,45 +5,74 @@ name: Go
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "*" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "*" ]
 
 jobs:
 
   test:
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
+        os:
+          - macos-latest
+          - ubuntu-24.04
         llvm: [18]
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{matrix.os}}
     steps:
       - uses: actions/checkout@v4
 
-      - name: Update Homebrew
-        # 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
+      - name: Install dependencies
         if: startsWith(matrix.os, 'macos')
         run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }} bdw-gc
-          echo `brew --prefix llvm@${{ matrix.llvm }}`/bin >> $GITHUB_PATH
-      - name: Install LLVM ${{ matrix.llvm }} and libgc-dev
+          brew update
+          brew install llvm@${{matrix.llvm}} pkg-config bdw-gc openssl
+          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
-          echo /usr/lib/llvm-${{ matrix.llvm }}/bin >> $GITHUB_PATH
-    
+          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
+
+          # 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:
@@ -53,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
-          LLGOROOT=$PWD bash .github/workflows/test_llgo.sh
-      
-      - name: Test _demo and _pydemo
-        run: |
-          set +e
-          LLGOROOT=$PWD bash .github/workflows/test_demo.sh
-          exit 0
-      
+          echo "Test result on ${{matrix.os}} with LLVM ${{matrix.llvm}}" > result.md
+          bash .github/workflows/test_llgo.sh
+
+      - name: Test demos
+        continue-on-error: true
+        run: bash .github/workflows/test_demo.sh
+
       - name: Show test result
         run: cat result.md
 
@@ -83,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/populate_darwin_sysroot.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+set -e
+
+TMPDIR="$(mktemp -d)"
+export TMPDIR
+trap 'rm -rf "${TMPDIR}"' EXIT
+
+DARWIN_AMD64_LLVM_PREFIX=.sysroot/darwin/amd64/usr/local/opt/llvm@18
+DARWIN_ARM64_LLVM_PREFIX=.sysroot/darwin/arm64/opt/homebrew/opt/llvm@18
+mkdir -p "${DARWIN_AMD64_LLVM_PREFIX}" "${DARWIN_ARM64_LLVM_PREFIX}"
+
+BREW_LLVM_FORMULA_JSON="$(mktemp)"
+curl -fsSL https://formulae.brew.sh/api/formula/llvm.json > "${BREW_LLVM_FORMULA_JSON}"
+BREW_LLVM_AMD64_BOTTLE_URL=$(jq -r '.bottle.stable.files.sonoma.url' "${BREW_LLVM_FORMULA_JSON}")
+BREW_LLVM_ARM64_BOTTLE_URL=$(jq -r '.bottle.stable.files.arm64_sonoma.url' "${BREW_LLVM_FORMULA_JSON}")
+curl -fsSL -H "Authorization: Bearer QQ==" "${BREW_LLVM_AMD64_BOTTLE_URL}" | tar -xzf - --strip-components=2 -C "${DARWIN_AMD64_LLVM_PREFIX}"
+curl -fsSL -H "Authorization: Bearer QQ==" "${BREW_LLVM_ARM64_BOTTLE_URL}" | tar -xzf - --strip-components=2 -C "${DARWIN_ARM64_LLVM_PREFIX}"
+
+patch_homebrew_lib_dir() {
+	local LIB_DIR="$1"
+	local HOMEBREW_PREFIX="$2"
+	for DYLIB_FILE in "${LIB_DIR}"/*.dylib; do
+		if [[ -f "${DYLIB_FILE}" ]]; then
+			ID=$(otool -D "${DYLIB_FILE}" | grep '@@HOMEBREW_PREFIX@@' | awk '{print $1}')
+			if [[ -n "${ID}" ]]; then
+				NEW_ID=${ID/'@@HOMEBREW_PREFIX@@'/${HOMEBREW_PREFIX}}
+				install_name_tool -id "${NEW_ID}" "${DYLIB_FILE}"
+			fi
+
+			DEPS=$(otool -L "${DYLIB_FILE}" | grep '@@HOMEBREW_PREFIX@@' | awk '{print $1}')
+			for DEP in ${DEPS}; do
+				NEW_DEP=${DEP/'@@HOMEBREW_PREFIX@@'/${HOMEBREW_PREFIX}}
+				install_name_tool -change "${DEP}" "${NEW_DEP}" "${DYLIB_FILE}"
+			done
+		fi
+	done
+}
+patch_homebrew_lib_dir "${DARWIN_AMD64_LLVM_PREFIX}/lib" /usr/lib
+patch_homebrew_lib_dir "${DARWIN_ARM64_LLVM_PREFIX}/lib" /opt/homebrew

.github/workflows/populate_linux_sysroot.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+set -e
+
+TMPDIR="$(mktemp -d)"
+export TMPDIR
+trap 'rm -rf "${TMPDIR}"' EXIT
+
+LINUX_AMD64_PREFIX=.sysroot/linux/amd64
+LINUX_ARM64_PREFIX=.sysroot/linux/arm64
+mkdir -p "${LINUX_AMD64_PREFIX}" "${LINUX_ARM64_PREFIX}"
+
+POPULATE_LINUX_SYSROOT_SCRIPT="$(mktemp)"
+cat > "${POPULATE_LINUX_SYSROOT_SCRIPT}" << EOF
+#!/bin/bash
+
+export DEBIAN_FRONTEND=noninteractive
+
+apt-get update
+apt-get install -y lsb-release gnupg2 wget rsync
+
+echo "deb http://apt.llvm.org/\$(lsb_release -cs)/ llvm-toolchain-\$(lsb_release -cs)-18 main" | tee /etc/apt/sources.list.d/llvm.list
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
+apt-get update
+apt-get install -y llvm-18-dev
+
+error() {
+	echo -e "\$1" >&2
+	exit 1
+}
+
+exclude_list=()
+include_list=()
+
+exclude_list+=(--exclude "/bin")
+exclude_list+=(--exclude "/boot")
+exclude_list+=(--exclude "/boot*")
+exclude_list+=(--exclude "/dev")
+exclude_list+=(--exclude "/etc")
+exclude_list+=(--exclude "/home")
+exclude_list+=(--exclude "/lib/dhcpd")
+exclude_list+=(--exclude "/lib/firmware")
+exclude_list+=(--exclude "/lib/hdparm")
+exclude_list+=(--exclude "/lib/ifupdown")
+exclude_list+=(--exclude "/lib/modules")
+exclude_list+=(--exclude "/lib/modprobe.d")
+exclude_list+=(--exclude "/lib/modules-load.d")
+exclude_list+=(--exclude "/lib/resolvconf")
+exclude_list+=(--exclude "/lib/startpar")
+exclude_list+=(--exclude "/lib/systemd")
+exclude_list+=(--exclude "/lib/terminfo")
+exclude_list+=(--exclude "/lib/udev")
+exclude_list+=(--exclude "/lib/xtables")
+exclude_list+=(--exclude "/lib/ssl/private")
+exclude_list+=(--exclude "/lost+found")
+exclude_list+=(--exclude "/media")
+exclude_list+=(--exclude "/mnt")
+exclude_list+=(--exclude "/proc")
+exclude_list+=(--exclude "/root")
+exclude_list+=(--exclude "/run")
+exclude_list+=(--exclude "/sbin")
+exclude_list+=(--exclude "/srv")
+exclude_list+=(--exclude "/sys")
+exclude_list+=(--exclude "/tmp")
+exclude_list+=(--exclude "/usr/bin")
+exclude_list+=(--exclude "/usr/games")
+exclude_list+=(--exclude "/usr/sbin")
+exclude_list+=(--exclude "/usr/share")
+exclude_list+=(--exclude "/usr/src")
+exclude_list+=(--exclude "/usr/local/bin")
+exclude_list+=(--exclude "/usr/local/etc")
+exclude_list+=(--exclude "/usr/local/games")
+exclude_list+=(--exclude "/usr/local/man")
+exclude_list+=(--exclude "/usr/local/sbin")
+exclude_list+=(--exclude "/usr/local/share")
+exclude_list+=(--exclude "/usr/local/src")
+exclude_list+=(--exclude "/usr/lib/ssl/private")
+exclude_list+=(--exclude "/var")
+exclude_list+=(--exclude "/snap")
+exclude_list+=(--exclude "*python*")
+
+include_list+=(--include "*.a")
+include_list+=(--include "*.so")
+include_list+=(--include "*.so.*")
+include_list+=(--include "*.h")
+include_list+=(--include "*.hh")
+include_list+=(--include "*.hpp")
+include_list+=(--include "*.hxx")
+include_list+=(--include "*.pc")
+include_list+=(--include "*.def")
+include_list+=(--include "*.inc")
+include_list+=(--include "/lib")
+include_list+=(--include "/lib32")
+include_list+=(--include "/lib64")
+include_list+=(--include "/libx32")
+include_list+=(--include "*/")
+
+do-sync() {
+	from=\$1
+	to=\$2
+
+	args=()
+	args+=(-a)
+	args+=(-z)
+	args+=(-m)
+	args+=(-d)
+	args+=(-h)
+	args+=(--keep-dirlinks)
+	args+=("--info=progress2")
+	args+=(--delete)
+	args+=(--prune-empty-dirs)
+	args+=(--sparse)
+	args+=(--links)
+	args+=(--copy-unsafe-links)
+	args+=("\${exclude_list[@]}")
+	args+=("\${include_list[@]}")
+	args+=(--exclude "*")
+	args+=("\${from}")
+	args+=("\${to}")
+
+	echo "\${args[@]}"
+	rsync "\${args[@]}"
+
+	exit \$?
+}
+
+do-sync / /sysroot/
+EOF
+chmod +x "${POPULATE_LINUX_SYSROOT_SCRIPT}"
+
+populate_linux_sysroot() {
+	local ARCH="$1"
+	local PREFIX="$2"
+	docker run \
+		--rm \
+		--platform "linux/${ARCH}" \
+		-v "$(pwd)/${PREFIX}":/sysroot \
+		-v "${POPULATE_LINUX_SYSROOT_SCRIPT}":/populate_linux_sysroot.sh \
+		debian:bullseye \
+		/populate_linux_sysroot.sh
+}
+populate_linux_sysroot amd64 "${LINUX_AMD64_PREFIX}"
+populate_linux_sysroot arm64 "${LINUX_ARM64_PREFIX}"

.github/workflows/release-build.yml

@@ -0,0 +1,58 @@
+name: Release Build
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  populate-darwin-sysroot:
+    runs-on: macos-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Populate Darwin sysroot
+        run: bash .github/workflows/populate_darwin_sysroot.sh
+      - name: Create Darwin sysroot tarball
+        run: tar -czvf .sysroot/darwin.tar.gz -C .sysroot darwin
+      - name: Upload Darwin sysroot tarball
+        uses: actions/upload-artifact@v4
+        with:
+          name: darwin-sysroot-tarball
+          path: .sysroot/darwin.tar.gz
+          compression-level: 0
+  build:
+    runs-on: ubuntu-latest
+    needs: populate-darwin-sysroot
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 1.20.x
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Download Darwin sysroot tarball
+        uses: actions/download-artifact@v4
+        with:
+          name: darwin-sysroot-tarball
+          path: .sysroot
+      - name: Populate Darwin sysroot
+        run: tar -xzvf .sysroot/darwin.tar.gz -C .sysroot
+      - name: Populate Linux sysroot
+        run: bash .github/workflows/populate_linux_sysroot.sh
+      - name: Run GoReleaser
+        env:
+          GITHUB_TOKEN: ${{github.token}}
+        run: |
+          docker run \
+            --rm \
+            -e GITHUB_TOKEN=${GITHUB_TOKEN} \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v $(pwd):/go/src/llgo \
+            -w /go/src/llgo \
+            ghcr.io/goreleaser/goreleaser-cross:v1.22 \
+            release --clean --skip nfpm,snapcraft

.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 -v "$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,10 +1,8 @@
 #!/bin/bash
 set -e
 
-export LLGOROOT=$PWD
-
 testcmd=/tmp/test
-llgo build -o $testcmd ./_test
+llgo build -o $testcmd ./c/bdwgc/_test
 cases=$($testcmd)
 total=$(echo "$cases" | wc -l | tr -d ' ')
 failed=0

.gitignore

@@ -35,3 +35,7 @@ build.dir/
 
 # Go workspace file
 go.work*
+
+# GoReleaser
+.dist/
+.sysroot/

.goreleaser.yaml

@@ -0,0 +1,145 @@
+version: 2
+
+dist: .dist
+
+env:
+  - SYSROOT_DARWIN_AMD64={{.Env.PWD}}/.sysroot/darwin/amd64
+  - SYSROOT_DARWIN_ARM64={{.Env.PWD}}/.sysroot/darwin/arm64
+  - SYSROOT_LINUX_AMD64={{.Env.PWD}}/.sysroot/linux/amd64
+  - SYSROOT_LINUX_ARM64={{.Env.PWD}}/.sysroot/linux/arm64
+  - CGO_ENABLED=1
+  - CGO_CXXFLAGS=-std=c++17
+
+before:
+  hooks:
+    - go mod download
+
+builds:
+  - id: llgo-darwin-amd64
+    main: ./cmd/llgo
+    flags:
+      - -tags=darwin,amd64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -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
+      - CXX=o64-clang++
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_AMD64}}/usr/local/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+    targets:
+      - darwin_amd64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-darwin-arm64
+    main: ./cmd/llgo
+    flags:
+      - -tags=darwin,arm64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -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
+      - CXX=oa64-clang++
+      - CGO_CPPFLAGS=-I{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=-L{{.Env.SYSROOT_DARWIN_ARM64}}/opt/homebrew/opt/llvm@18/lib -Wl,-search_paths_first -Wl,-headerpad_max_install_names -lLLVM-18 -lz -lm
+    targets:
+      - darwin_arm64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-linux-amd64
+    main: ./cmd/llgo
+    flags:
+      - -tags=linux,amd64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -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
+      - CXX=x86_64-linux-gnu-g++
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_AMD64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_AMD64}} -L{{.Env.SYSROOT_LINUX_AMD64}}/usr/lib/llvm-18/lib -lLLVM-18
+    targets:
+      - linux_amd64
+    mod_timestamp: "{{.CommitTimestamp}}"
+  - id: llgo-linux-arm64
+    main: ./cmd/llgo
+    flags:
+      - -tags=linux,arm64,byollvm
+    ldflags:
+      - -X github.com/goplus/llgo/x/env.buildVersion=v{{.Version}}
+      - -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
+      - CXX=aarch64-linux-gnu-g++
+      - CGO_CPPFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-18 -I{{.Env.SYSROOT_LINUX_ARM64}}/usr/include/llvm-c-18 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS
+      - CGO_LDFLAGS=--sysroot={{.Env.SYSROOT_LINUX_ARM64}} -L{{.Env.SYSROOT_LINUX_ARM64}}/usr/lib/llvm-18/lib -lLLVM-18
+    targets:
+      - linux_arm64
+    mod_timestamp: "{{.CommitTimestamp}}"
+
+archives:
+  - format: tar.gz
+    name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+    files:
+      - LICENSE
+      - README.md
+
+checksum:
+  name_template: "{{.ProjectName}}{{.Version}}.checksums.txt"
+
+nfpms:
+  - package_name: llgo
+    vendor: goplus
+    homepage: https://github.com/goplus/llgo
+    maintainer: Aofei Sheng <aofei@aofeisheng.com>
+    description: |
+      LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a
+      subproject of the Go+ project.
+
+      LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+
+      - Game development
+      - AI and data science
+      - WebAssembly
+      - Embedded development
+      - ...
+    license: Apache-2.0
+    formats:
+      - deb
+      - rpm
+    file_name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+    bindir: /usr/local/bin
+
+snapcrafts:
+  - name: llgo
+    title: A Go compiler based on LLVM
+    summary: A Go compiler based on LLVM
+    description: |
+      LLGo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python. It's a
+      subproject of the Go+ project.
+
+      LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
+
+      - Game development
+      - AI and data science
+      - WebAssembly
+      - Embedded development
+      - ...
+    license: Apache-2.0
+    confinement: classic
+    name_template: >-
+      {{.ProjectName}}{{.Version}}.{{.Os}}-{{.Arch}}
+      {{- if .Arm}}v{{.Arm}}{{end}}
+
+snapshot:
+  name_template: '{{trimprefix .Summary "v"}}'
+
+release:
+  prerelease: auto

README.md

@@ -27,11 +27,13 @@ LLGo := Go + C + Python
 LLGo is compatible with C and Python through the language's **Application Binary Interface (ABI)**, while LLGo is compatible with Go through its **syntax (source code)**.
 
 
-## C standard libary support
+## C/C++ standard libary support
 
-You can import a C standard library in LLGo!
+You can import a C/C++ standard library in LLGo!
 
 * [c](https://pkg.go.dev/github.com/goplus/llgo/c)
+* [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)
@@ -40,6 +42,8 @@ You can import a 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/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:
 
@@ -69,6 +73,45 @@ llgo run .
 ```
 
 
+## How support C/C++ and Python
+
+LLGo use `go:linkname` to link an extern symbol througth its ABI:
+
+```go
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+```
+
+You can directly integrate it into [your own code](_demo/linkname/linkname.go):
+
+```go
+package main
+
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+
+func main() {
+	println("sqrt(2) =", Sqrt(2))
+}
+```
+
+Or put it into a package (see [c/math](c/math/math.go)):
+
+```go
+package main
+
+import "github.com/goplus/llgo/c/math"
+
+func main() {
+	println("sqrt(2) =", math.Sqrt(2))
+}
+```
+
+
 ## Python support
 
 You can import a Python library in LLGo!
@@ -171,10 +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:
 
@@ -186,7 +235,7 @@ Here are some examples related to them:
 
 ## Go syntax support
 
-All Go syntax is already supported. Here are some examples:
+All Go syntax (not including `cgo`) is already supported. Here are some examples:
 
 * [concat](_demo/concat/concat.go): define a variadic function
 * [genints](_demo/genints/genints.go): various forms of closure usage (including C function, recv.method and anonymous function)
@@ -195,7 +244,7 @@ All Go syntax 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.
 
@@ -220,33 +269,69 @@ 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)
+* [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)
-* [errors](https://pkg.go.dev/errors) (partially)
-* [io](https://pkg.go.dev/io) (partially)
-* [io/fs](https://pkg.go.dev/io/fs) (partially)
+* [runtime](https://pkg.go.dev/runtime) (partially)
 * [os](https://pkg.go.dev/os) (partially)
+* [os/exec](https://pkg.go.dev/os/exec) (partially)
 * [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))
-- [SQLite 3](https://www.sqlite.org) (optional, for [github.com/goplus/llgo/c/sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite))
-- [Python 3.11+](https://www.python.org) (optional, for [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py))
+- [OpenSSL 3.0+](https://www.openssl.org/)
+- [zlib 1.2+](https://www.zlib.net)
+- [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
 
@@ -255,14 +340,10 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 ### on macOS
 
 ```sh
-brew update # execute if needed
-brew install llvm@18 pkg-config libgc
-brew install cjson sqlite 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
-git clone https://github.com/goplus/llgo.git
-cd llgo
-export LLGOROOT="/path/to/llgo" # Replace this with the root directory of the llgo project
-go install -v ./...
+brew update
+brew install llvm@18 pkg-config bdw-gc openssl
+brew install python@3.12 # optional
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
 ### on Linux (Debian/Ubuntu)
@@ -270,14 +351,10 @@ go install -v ./...
 ```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 install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev
-sudo apt-get install -y libcjson-dev libsqlite3-dev 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
-git clone https://github.com/goplus/llgo.git
-cd llgo
-export LLGOROOT="/path/to/llgo" # Replace this with the root directory of the llgo project
-go install -v ./...
+sudo apt-get update
+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 python3.12-dev # optional
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
 ### on Windows
@@ -296,8 +373,9 @@ TODO
 How do I generate these tools?
 
 ```sh
-export CC=clang CXX=clang++ # only for go build; optional if you have other compatible compilers
-go install -v ./...  # compile all tools except pydump
+git clone https://github.com/goplus/llgo.git
+cd llgo
+go install -v ./chore/...  # compile all tools except pydump
 cd chore/_xtool
 llgo install ./...   # compile pydump
 go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1  # compile pysigfetch

_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

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+var c chan int
+
+func handle(int) {}
+
+func main() {
+	select {
+	case m := <-c:
+		handle(m)
+	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/ctxcancel/ctx.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"context"
+	"fmt"
+)
+
+func main() {
+	// gen generates integers in a separate goroutine and
+	// sends them to the returned channel.
+	// The callers of gen need to cancel the context once
+	// they are done consuming generated integers not to leak
+	// the internal goroutine started by gen.
+	gen := func(ctx context.Context) <-chan int {
+		dst := make(chan int)
+		n := 1
+		go func() {
+			for {
+				select {
+				case <-ctx.Done():
+					return // returning not to leak the goroutine
+				case dst <- n:
+					n++
+				}
+			}
+		}()
+		return dst
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel() // cancel when we are finished consuming integers
+
+	for n := range gen(ctx) {
+		fmt.Println(n)
+		if n == 5 {
+			break
+		}
+	}
+}

_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/flagdemo/flagdemo.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+func main() {
+	fmt.Println("args:", os.Args[1:])
+	if len(os.Args) == 1 {
+		os.Args = []string{"flagdemo", "-cpu", "100"}
+	}
+
+	verbose := flag.Bool("v", false, "verbose")
+	cpu := flag.Int("cpu", 1, "cpu number")
+	host := flag.String("host", ":8888", "host")
+	flag.Parse()
+
+	fmt.Println("host:", *host, "cpu:", *cpu, "verbose:", *verbose)
+}

_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

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+
+	"github.com/goplus/llgo/xtool/env/llvm"
+)
+
+func main() {
+	ls := "ls"
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+	}
+	cmd := exec.Command(ls)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Run()
+
+	dir := llvm.New("").BinDir()
+	fmt.Println(dir)
+}

_cmptest/osproc/exec.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+)
+
+func main() {
+	ls := "ls"
+	args := []string{ls, "-l"}
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+		args = []string{ls}
+	}
+	lspath, _ := exec.LookPath(ls)
+	if lspath != "" {
+		ls = lspath
+	}
+	proc, err := os.StartProcess(ls, args, &os.ProcAttr{
+		Files: []*os.File{nil, os.Stdout, os.Stderr},
+	})
+	if err != nil {
+		fmt.Println("os.StartProcess error:", err)
+		return
+	}
+	proc.Wait()
+	fmt.Println("proc.Wait done")
+}

_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/strconv/strconv.go

@@ -1,7 +1,12 @@
 package main
 
-import "strconv"
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
 
 func main() {
-	println(strconv.Itoa(-123))
+	fmt.Println(strconv.Itoa(-123))
+	fmt.Println(strings.Split("abc,def,123", ","))
 }

_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/cexec/exec.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+)
+
+func main() {
+	ls := c.Str("ls")
+	os.Execlp(ls, ls, c.Str("-l"), nil)
+}

_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/fcntl/fcntl.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+	"unsafe"
+)
+
+func main() {
+
+	filename := c.Str("testfile.txt")
+	data := c.Str("Hello, os!")
+	var buffer [20]c.Char
+
+	// Open a file, O_CREAT|O_WRONLY|O_TRUNC means create, write only, or clear the file
+	fd := os.Open(filename, os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0644)
+	if fd == -1 {
+		c.Printf(c.Str("open error\n"))
+		return
+	}
+
+	// Writing data to a file
+	bytesWritten := os.Write(fd, c.Pointer(data), c.Strlen(data))
+	if bytesWritten == -1 {
+		c.Printf(c.Str("write error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("Written %ld bytes to %s\n"), bytesWritten, filename)
+
+	// Get file status flags
+	flags := os.Fcntl(fd, os.F_GETFL)
+	if flags == -1 {
+		c.Printf(c.Str("os error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("File flags: %d\n"), flags)
+
+	// Set the file status flag to non-blocking mode
+	if os.Fcntl(fd, os.F_SETFL, flags|os.O_NONBLOCK) == -1 {
+		c.Printf(c.Str("os error\n"))
+		os.Close(fd)
+		return
+	}
+	c.Printf(c.Str("set file status successfully\n"))
+
+
+
+	c.Printf(c.Str("111"))
+	// Close file
+	os.Close(fd)
+
+	// Reopen the file, O_RDONLY means read-only
+	fd = os.Open(filename, os.O_RDONLY)
+	if fd == -1 {
+		c.Printf(c.Str("open error\n"))
+		return
+	}
+
+	// Reading data from a file
+	// &buffer[:][0]
+	// unsafe.SliceData(buffer[:])
+	bytesRead := os.Read(fd, c.Pointer(unsafe.SliceData(buffer[:])), unsafe.Sizeof(buffer)-1)
+	if bytesRead == -1 {
+		c.Printf(c.Str("read error\n"))
+		os.Close(fd)
+		return
+	}
+
+	// Ensure that the buffer is null-terminated
+	buffer[bytesRead] = c.Char(0)
+	c.Printf(c.Str("Read %ld bytes: %s\n"), bytesRead, &buffer[0])
+
+	// Close file
+	os.Close(fd)
+}

_demo/hello/hello.go

@@ -9,5 +9,5 @@ func main() {
 }
 
 /* Expected output:
-Hello World
+Hello world
 */

_demo/linkname/linkname.go

@@ -0,0 +1,10 @@
+package main
+
+import _ "unsafe" // for go:linkname
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+
+func main() {
+	println("sqrt(2) =", Sqrt(2))
+}

_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/logdemo/log.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"log"
+)
+
+func main() {
+	log.Println("Hello")
+}

_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/oslookpath/lookpath.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+)
+
+func main() {
+	ls := "ls"
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+	}
+	lspath, _ := exec.LookPath(ls)
+	if lspath != "" {
+		ls = lspath
+	}
+	fmt.Println(ls)
+}

_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

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

_demo/socket/server/server.go

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

_demo/sysexec/exec.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+	"syscall"
+)
+
+func main() {
+	ls := "ls"
+	args := []string{ls, "-l"}
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+		args = []string{ls}
+	}
+	lspath, _ := exec.LookPath(ls)
+	if lspath != "" {
+		ls = lspath
+	}
+	err := syscall.Exec(ls, args, nil)
+	if err != nil {
+		fmt.Println("syscall.Exec error:", err)
+		return
+	}
+}

_demo/timedur/timedur.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	t := time.Now().Add(time.Second * 5)
+	fmt.Println(time.Until(t))
+}

c/bdwgc/_test/bdwgc.go

@@ -3,9 +3,9 @@ package main
 import (
 	"unsafe"
 
-	"github.com/goplus/llgo/_test/testing"
 	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/c/bdwgc"
+	"github.com/goplus/llgo/c/bdwgc/_test/testing"
 )
 
 // ------ Test malloc ------

c/bdwgc/_test/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/goplus/llgo/_test/testing"
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/bdwgc/_test/testing"
 )
 
 type TestCase struct {

c/c.go

@@ -28,6 +28,7 @@ const (
 )
 
 type (
+	Void    = [0]byte
 	Char    = int8
 	Float   = float32
 	Double  = float64
@@ -68,6 +69,9 @@ func Alloca(size uintptr) Pointer
 //go:linkname AllocaCStr llgo.allocaCStr
 func AllocaCStr(s string) *Char
 
+//go:linkname AllocaCStrs llgo.allocaCStrs
+func AllocaCStrs(strs []string, endWithNil bool) **Char
+
 // TODO(xsw):
 // llgo:link AllocaNew llgo.allocaNew
 func AllocaNew[T any]() *T { return nil }
@@ -75,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)
 
@@ -212,10 +219,16 @@ func Fputs(s *Char, fp FilePtr) Int
 //go:linkname Fflush C.fflush
 func Fflush(fp FilePtr) Int
 
-// -----------------------------------------------------------------------------
+//go:linkname Fopen C.fopen
+func Fopen(c *Char, mod *Char) FilePtr
 
-//go:linkname Time C.time
-func Time(*int32) int32
+//go:linkname Fclose C.fclose
+func Fclose(fp FilePtr) Int
+
+//go:linkname Perror C.perror
+func Perror(s *Char)
+
+// -----------------------------------------------------------------------------
 
 //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,49 +0,0 @@
-package main
-
-import (
-	"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() {
-	index := clang.CreateIndex(0, 0)
-	unit := index.ParseTranslationUnit(
-		c.Str("todo"),
-		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

@@ -0,0 +1,82 @@
+#include <clang-c/Index.h>
+#include <stdio.h>
+
+typedef enum CXChildVisitResult (*wrap_CXCursorVisitor)(CXCursor *cursor, CXCursor *parent, CXClientData client_data);
+
+typedef struct {
+    CXClientData data;
+    wrap_CXCursorVisitor visitor;
+} wrap_data;
+
+CXChildVisitResult wrap_visitor(CXCursor cursor, CXCursor parent, CXClientData data) {
+    wrap_data *d = (wrap_data *)(data);
+    return d->visitor(&cursor, &parent, d->data);
+}
+
+extern "C" {
+
+CXString wrap_clang_getCursorSpelling(CXCursor *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);
+}
+
+void wrap_clang_getTranslationUnitCursor(CXTranslationUnit uint, CXCursor *cur) {
+    *cur = clang_getTranslationUnitCursor(uint);
+}
+
+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/clang/_wrap/llgo_check.cpp

@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include <clang-c/Index.h>
+
+int main() {
+    printf("sizeof(clang.Cursor) = %lu\n", sizeof(CXCursor));
+    return 0;
+}

c/clang/_wrap/llgo_check.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/clang"
+)
+
+const (
+	LLGoCFlags = "-I$(llvm-config --includedir)"
+)
+
+func main() {
+	c.Printf(c.Str("sizeof(clang.Cursor) = %lu\n"), unsafe.Sizeof(clang.Cursor{}))
+}

c/clang/basic.go

@@ -38,13 +38,13 @@ type String struct {
 /**
  * Retrieve the character data associated with the given string.
  */
-// llgo:link C.clang_getCString
+// llgo:link String.CStr C.clang_getCString
 func (String) CStr() *c.Char { return nil }
 
 /**
  * Free the given string.
  */
-// llgo:link C.clang_disposeString
+// llgo:link String.Dispose C.clang_disposeString
 func (String) Dispose() {}
 
 type StringSet struct {
@@ -55,5 +55,5 @@ type StringSet struct {
 /**
  * Free the given string set.
  */
-// llgo:link C.clang_disposeStringSet
+// llgo:link (*StringSet).Dispose C.clang_disposeStringSet
 func (*StringSet) Dispose() {}

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

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func coroutineFunc(L *lua.State) {
+	L.Loadstring(c.Str(`
+	function coro_func()
+	   for i = 1, 5 do
+	       coroutine.yield(i)
+	   end
+	end
+	`))
+	L.Pcall(0, 0, 0)
+	L.Getglobal(c.Str("coro_func"))
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+
+	coroutineFunc(L) // Load and get the coroutine function
+
+	co := L.Newthread() // Create a new coroutine/thread
+	L.Pushvalue(-2)     // Move the function to the top of the stack
+	L.Xmove(co, 1)      // Move the function to the new coroutine
+
+	var nres c.Int
+	var status c.Int
+
+	c.Printf(c.Str("Resuming coroutine...\n"))
+	// Resume coroutine and handle yields
+	for {
+		status = co.Resume(nil, 0, &nres)
+		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
+
+			// Check if the coroutine is yieldable
+			if co.Isyieldable() != 0 {
+				c.Printf(c.Str("Coroutine is yieldable.\n"))
+			} else {
+				c.Printf(c.Str("Coroutine is not yieldable.\n"))
+			}
+
+		} else {
+			break
+		}
+	}
+
+	// Check the final status of the coroutine
+	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/error/error.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+	L.Openlibs()
+	if res := L.Loadstring(c.Str("function doubleNumber(x) ! return x * 2 end")); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+}
+
+/* Expected output:
+error: [string "function doubleNumber(x) ! return x * 2 end"]:1: unexpected symbol near '!'
+*/

c/lua/_demo/funccall-concat/funccall.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	if res := L.Dostring(c.Str("function combineParams(num, str) return 'Result: ' .. str .. '  ' .. num end")); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+	L.Getglobal(c.Str("combineParams"))
+	L.Pushnumber(3.14159)
+	L.Pushstring(c.Str("Hello, World!"))
+	if res := L.Pcall(2, 1, 0); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+	if res := L.Isstring(-1); res != 0 {
+		result := L.Tostring(-1)
+		c.Printf(result)
+	}
+}
+
+/* Expected output:
+Result: Hello, World!  3.14159
+*/

c/lua/_demo/funccall-number/funccall.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	if res := L.Loadstring(c.Str("function doubleNumber(x) return x * 2 end")); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+	if res := L.Pcall(0, 0, 0); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+
+	L.Getglobal(c.Str("doubleNumber"))
+	L.Pushnumber(10)
+
+	if res := L.Pcall(1, 1, 0); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+
+	if res := L.Isnumber(-1); res != 0 {
+		result := L.Tointeger(-1)
+		c.Printf(c.Str("result: %lld\n"), result)
+	} else {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+}
+
+/* Expected output:
+result: 20
+*/

c/lua/_demo/funccall-string/funccall.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	code := c.Str(
+		`function processStrings(a, b, c)
+	print('Received string a: ' .. a)
+	print('Received string b: ', b)
+	print('Received string c (formatted): ' .. c)
+	return a .. b .. c
+end`)
+
+	if res := L.Dostring(code); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+
+	L.Getglobal(c.Str("processStrings"))
+
+	L.Pushstring(c.Str("Hello, World!"))
+	L.Pushlstring(c.Str(`Hello Lua In LLGO`), 17)
+	L.Pushfstring(c.Str(`Hello %s In %d`), c.Str("LLGO"), 2024)
+
+	if res := L.Pcall(3, 1, 0); res != lua.OK {
+		c.Printf(c.Str("error: %s\n"), L.Tostring(-1))
+	}
+
+	if res := L.Isstring(-1); res != 0 {
+		result := L.Tostring(-1)
+		c.Printf(c.Str("result: %s\n"), result)
+	}
+}
+
+/* Expected output:
+Received string a: Hello, World!
+Received string b:      Hello Lua In LLGO
+Received string c (formatted): Hello LLGO In 2024
+result: Hello, World!Hello Lua In LLGOHello LLGO In 2024
+*/

c/lua/_demo/hello/hello.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+	L.Openlibs()
+	if res := L.Dostring(c.Str("print('hello world')")); res != lua.OK {
+		println("error")
+	}
+}
+
+/* Expected output:
+hello world
+*/

c/lua/_demo/loadcall/loadcall.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+	if res := L.Loadstring(c.Str("print('hello world')")); res != lua.OK {
+		println("error")
+	}
+	if res := L.Pcall(0, 0, 0); res != lua.OK {
+		println("error")
+	}
+
+}
+
+/* Expected output:
+hello world
+*/

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/_demo/stack/stack.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+// printStack prints the current stack of the given Lua state.
+func printStack(L *lua.State, stateName *c.Char) {
+	top := L.Gettop()
+	c.Printf(c.Str("%s stack (top=%d):"), stateName, top)
+	for i := 1; i <= int(top); i++ {
+		c.Printf(c.Str("%s "), L.Tostring(c.Int(i)))
+	}
+	c.Printf(c.Str("\n"))
+}
+
+func main() {
+	// Create a new Lua state and open libraries
+	L := lua.Newstate()
+	defer L.Close()
+	L.Openlibs()
+
+	// Push initial values onto the stack
+	L.Pushstring(c.Str("Hello"))
+	L.Pushstring(c.Str("LLGO"))
+	L.Pushnumber(2024)
+
+	// Print initial stack
+	c.Printf(c.Str("Initial stack:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Use absindex to ensure the index is positive
+	idx := -2
+	absIdx := L.Absindex(c.Int(idx))
+	c.Printf(c.Str("Absolute index of 'LLGO': %d\n"), absIdx)
+
+	// Copy 'LLGO' to the top of the stack
+	L.Pushvalue(absIdx)
+	c.Printf(c.Str("\nAfter pushing 'LLGO' to the top:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Rotate stack elements
+	L.Rotate(c.Int(1), c.Int(-1))
+	c.Printf(c.Str("\nAfter rotating the stack:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Copy the top element to index 2
+	L.Copy(c.Int(-1), c.Int(2))
+	c.Printf(c.Str("\nAfter copying the top element to index 2:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Check if we can grow the stack
+	if L.Checkstack(c.Int(2)) == 0 {
+		c.Printf(c.Str("Cannot grow stack\n"))
+		return
+	}
+
+	// Push additional elements
+	L.Pushnumber(3.14)
+	L.Pushstring(c.Str("Lua"))
+	c.Printf(c.Str("\nAfter pushing more elements:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Set the top of the stack, clearing extra elements
+	L.Settop(c.Int(5))
+	c.Printf(c.Str("\nAfter setting top to 5:\n"))
+	printStack(L, c.Str("L1"))
+
+	// Create a second Lua state
+	L1 := lua.Newstate()
+	defer L1.Close()
+
+	// Move two elements to the new state
+	L.Xmove(L1, c.Int(2))
+	c.Printf(c.Str("\nAfter moving two elements to L1:\n"))
+	printStack(L, c.Str("L1"))
+	printStack(L1, c.Str("L2"))
+}
+
+/* Expected output:
+Initial stack:
+L1 stack (top=3):Hello LLGO 2024.0
+Absolute index of 'LLGO': 2
+
+After pushing 'LLGO' to the top:
+L1 stack (top=4):Hello LLGO 2024.0 LLGO
+
+After rotating the stack:
+L1 stack (top=4):LLGO 2024.0 LLGO Hello
+
+After copying the top element to index 2:
+L1 stack (top=4):LLGO Hello LLGO Hello
+
+After pushing more elements:
+L1 stack (top=6):LLGO Hello LLGO Hello 3.14 Lua
+
+After setting top to 5:
+L1 stack (top=5):LLGO Hello LLGO Hello 3.14
+
+After moving two elements to L1:
+L1 stack (top=3):LLGO Hello LLGO
+L2 stack (top=2):Hello 3.14
+*/

c/lua/_demo/table/table.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/lua"
+)
+
+func printTable(L *lua.State) {
+	L.Pushnil()
+	for L.Next(-2) != 0 {
+		key := L.Tostring(-2)
+		value := L.Tostring(-1)
+		c.Printf(c.Str("%s - %s\n"), key, value)
+		L.Pop(1)
+	}
+	L.Pop(1)
+}
+
+func main() {
+	L := lua.Newstate()
+	defer L.Close()
+
+	L.Openlibs()
+
+	L.Newtable()
+
+	L.Pushstring(c.Str("name"))
+	L.Pushstring(c.Str("John"))
+	L.Settable(-3)
+
+	L.Pushstring(c.Str("age"))
+	L.Pushnumber(30)
+	L.Settable(-3)
+
+	L.Pushstring(c.Str("John Doe"))
+	L.Setfield(-2, c.Str("fullname"))
+
+	L.Getfield(-1, c.Str("name"))
+	c.Printf(c.Str("%s\n"), L.Tostring(-1))
+	L.Pop(1)
+
+	L.Pushstring(c.Str("age"))
+	L.Gettable(-2)
+	age := int(L.Tonumber(-1))
+	c.Printf(c.Str("Age: %d\n"), age)
+	L.Pop(1)
+
+	c.Printf(c.Str("All entries in the table:\n"))
+	printTable(L)
+
+}
+
+/* Expected output:
+John
+Age: 30
+All entries in the table:
+age - 30.0
+fullname - John Doe
+name - John
+*/

c/lua/lauxlib.go

@@ -0,0 +1,101 @@
+package lua
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// /* global table */
+
+// /* extra error code for 'luaL_loadfilex' */
+
+// /* key, in the registry, for table of loaded modules */
+
+// /* key, in the registry, for table of preloaded loaders */
+
+// /* predefined references */
+
+// llgo:link (*State).Loadfilex C.luaL_loadfilex
+func (L *State) Loadfilex(filename *c.Char, mode *c.Char) c.Int { return 0 }
+
+func (L *State) Loadfile(filename *c.Char) c.Int { return L.Loadfilex(filename, nil) }
+
+// llgo:link (*State).Loadstring C.luaL_loadstring
+func (L *State) Loadstring(s *c.Char) c.Int { return 0 }
+
+//go:linkname Newstate C.luaL_newstate
+func Newstate() *State
+
+// /*
+// ** ===============================================================
+// ** some useful macros
+// ** ===============================================================
+// */
+
+func (L *State) Dofile(filename *c.Char) c.Int {
+	if loadResult := L.Loadfile(filename); loadResult != 0 {
+		return loadResult
+	}
+	return L.Pcall(c.Int(0), c.Int(MULTRET), c.Int(0))
+}
+
+func (L *State) Dostring(str *c.Char) c.Int {
+	if loadResult := L.Loadstring(str); loadResult != 0 {
+		return loadResult
+	}
+	return L.Pcall(c.Int(0), c.Int(MULTRET), c.Int(0))
+}
+
+// /*
+// ** Perform arithmetic operations on lua_Integer values with wrap-around
+// ** semantics, as the Lua core does.
+// */
+
+// /* push the value used to represent failure/error */
+
+// /*
+// ** {======================================================
+// ** Generic Buffer manipulation
+// ** =======================================================
+// */
+
+// /* }====================================================== */
+
+// /*
+// ** {======================================================
+// ** File handles for IO library
+// ** =======================================================
+// */
+
+// /*
+// ** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+// ** initial structure 'luaL_Stream' (it may contain other fields
+// ** after that initial structure).
+// */
+
+// #define LUA_FILEHANDLE          "FILE*"
+
+// /* }====================================================== */
+
+// /*
+// ** {==================================================================
+// ** "Abstraction Layer" for basic report of messages and errors
+// ** ===================================================================
+// */
+
+// /* print a string */
+
+// /* print a newline and flush the output */
+
+// /* print an error message */
+
+// /* }================================================================== */
+
+// /*
+// ** {============================================================
+// ** Compatibility with deprecated conversions
+// ** =============================================================
+// */
+
+// /* }============================================================ */

c/lua/lua.go

@@ -0,0 +1,504 @@
+package lua
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "link: $(pkg-config --libs lua); -llua -lm"
+)
+
+// /* mark for precompiled code ('<esc>Lua') */
+
+// /* option for multiple returns in 'lua_pcall' and 'lua_call' */
+const (
+	MULTRET = -1
+)
+
+// /*
+// ** Pseudo-indices
+// ** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
+// ** space after that to help overflow detection)
+// */
+
+// /* thread status */
+const (
+	OK        = 0
+	YIELD     = 1
+	ERRRUN    = 2
+	ERRSYNTAX = 3
+	ERRMEM    = 4
+	ERRERR    = 5
+)
+
+type State struct {
+	Unused [8]byte
+}
+
+// /*
+// ** basic types
+// */
+const (
+	NONE          c.Int = -1
+	NIL           c.Int = 0
+	BOOLEAN       c.Int = 1
+	LIGHTUSERDATA c.Int = 2
+	NUMBER        c.Int = 3
+	STRING        c.Int = 4
+	TABLE         c.Int = 5
+	FUNCTION      c.Int = 6
+	USERDATA      c.Int = 7
+	THREAD        c.Int = 8
+	UMTYPES       c.Int = 9
+)
+
+// /* minimum Lua stack available to a C function */
+const (
+	MINSTACK = 20
+)
+
+// /* predefined values in the registry */
+const (
+	RIDX_MAINTHREAD = 1
+	RIDX_GLOBALS    = 2
+	RIDX_LAST       = RIDX_GLOBALS
+)
+
+// /* type of numbers in Lua */
+type Number = c.Double
+
+// /* type for integer functions */
+// TODO(zzy):consider dynamic size
+
+type Integer = c.Int
+
+// /* unsigned integer type */
+type Unsigned = c.Uint
+
+// /* type for continuation-function contexts */
+type KContext = c.Pointer
+
+// /*
+// ** Type for C functions registered with Lua
+// */
+
+// llgo:type C
+type CFunction func(L *State) c.Int
+
+// /*
+// ** Type for continuation functions
+// */
+
+// TODO(zzy): KFunction does not currently support
+type KFunction func(L *State, status c.Int, ctx KContext) c.Int
+
+// /*
+// ** Type for functions that read/write blocks when loading/dumping Lua chunks
+// */
+
+// typedef const char * (*lua_Reader) (State *L, void *ud, size_t *sz);
+// typedef int (*lua_Writer) (State *L, const void *p, size_t sz, void *ud);
+
+// /*
+// ** Type for memory-allocation functions
+// */
+
+// typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+// /*
+// ** Type for warning functions
+// */
+
+// typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);
+
+// /*
+// ** Type used by the debug API to collect debug information
+// */
+
+// typedef struct lua_Debug lua_Debug;
+
+// /*
+// ** Functions to be called by the debugger in specific events
+// */
+
+// typedef void (*lua_Hook) (State *L, lua_Debug *ar);
+
+// /*
+// ** generic extra include file
+// */
+
+// #if defined(LUA_USER_H)
+// #include LUA_USER_H
+// #endif
+
+// /*
+// ** RCS ident string
+// */
+
+// extern const char lua_ident[];
+
+// /*
+// ** state manipulation
+// */
+// llgo:link (*State).Close C.lua_close
+func (L *State) Close() {}
+
+// State *(lua_newstate) (lua_Alloc f, void *ud);
+
+// llgo:link (*State).Newthread C.lua_newthread
+func (L *State) Newthread() *State { return nil }
+
+// int        (lua_closethread) (State *L, State *from);
+// int        (lua_resetthread) (State *L);  /* Deprecated! */
+// lua_CFunction (lua_atpanic) (State *L, lua_CFunction panicf);
+// lua_Number (lua_version) (State *L);
+
+// /*
+// ** basic stack manipulation
+// */
+
+// llgo:link (*State).Absindex C.lua_absindex
+func (L *State) Absindex(idx c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Gettop C.lua_gettop
+func (L *State) Gettop() c.Int { return 0 }
+
+// llgo:link (*State).Settop C.lua_settop
+func (L *State) Settop(idx c.Int) {}
+
+// llgo:link (*State).Pushvalue C.lua_pushvalue
+func (L *State) Pushvalue(idx c.Int) {}
+
+// llgo:link (*State).Rotate C.lua_rotate
+func (L *State) Rotate(idx c.Int, n c.Int) {}
+
+// llgo:link (*State).Copy C.lua_copy
+func (L *State) Copy(fromidx c.Int, toidx c.Int) {}
+
+// llgo:link (*State).Checkstack C.lua_checkstack
+func (L *State) Checkstack(n c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Xmove C.lua_xmove
+func (L *State) Xmove(to *State, n c.Int) {}
+
+// /*
+// ** access functions (stack -> C)
+// */
+
+// llgo:link (*State).Isnumber C.lua_isnumber
+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 }
+
+// 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 }
+
+// llgo:link (*State).Typename C.lua_typename
+func (L *State) Typename(tp c.Int) *c.Char { return nil }
+
+// llgo:link (*State).Tonumberx C.lua_tonumberx
+func (L *State) Tonumberx(idx c.Int, isnum *c.Int) Number { return 0 }
+
+// llgo:link (*State).Tointegerx C.lua_tointegerx
+func (L *State) Tointegerx(idx c.Int, isnum *c.Int) Integer { return 0 }
+
+// llgo:link (*State).Toboolean C.lua_toboolean
+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 lua_Unsigned    (lua_rawlen) (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);
+
+// /*
+// ** Comparison and arithmetic functions
+// */
+
+// /*
+// ** push functions (C -> stack)
+// */
+// llgo:link (*State).Pushnil C.lua_pushnil
+func (L *State) Pushnil() {}
+
+// llgo:link (*State).Pushnumber C.lua_pushnumber
+func (L *State) Pushnumber(n Number) {}
+
+// llgo:link (*State).Pushinteger C.lua_pushinteger
+func (L *State) Pushinteger(n Integer) {}
+
+// llgo:link (*State).Pushlstring C.lua_pushlstring
+func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char { 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) {}
+
+//void  (lua_pushlightuserdata) (State *L, void *p);
+//int   (lua_pushthread) (State *L);
+
+// /*
+// ** get functions (Lua -> stack)
+// */
+
+// llgo:link (*State).Getglobal C.lua_getglobal
+func (L *State) Getglobal(name *c.Char) c.Int { return 0 }
+
+// llgo:link (*State).Gettable C.lua_gettable
+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 }
+
+// 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);
+
+// 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)
+// */
+
+// llgo:link (*State).Setglobal C.lua_setglobal
+func (L *State) Setglobal(name *c.Char) {}
+
+// llgo:link (*State).Settable C.lua_settable
+func (L *State) Settable(idx c.Int) {}
+
+// llgo:link (*State).Setfield C.lua_setfield
+func (L *State) Setfield(idx c.Int, k *c.Char) {}
+
+//void  (lua_seti) (State *L, int idx, lua_Integer n);
+//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);
+
+// 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 {
+	return 0
+}
+
+func (L *State) Pcall(nargs c.Int, nresults c.Int, errfunc c.Int) c.Int {
+	return L.Pcallk(nargs, nresults, errfunc, nil, nil)
+}
+
+// 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);
+
+// /*
+// ** coroutine functions
+// */
+
+// llgo:link (*State).Resume C.lua_resume
+func (L *State) Resume(from *State, narg c.Int, nres *c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Status C.lua_status
+func (L *State) Status() c.Int { return 0 }
+
+// llgo:link (*State).Isyieldable C.lua_isyieldable
+func (L *State) Isyieldable() c.Int { return 0 }
+
+// llgo:link (*State).Yieldk C.lua_yieldk
+func (L *State) Yieldk(nresults c.Int, ctx KContext, k KFunction) c.Int { return 0 }
+func (L *State) Yield(nresults c.Int) c.Int                             { return L.Yieldk(nresults, nil, nil) }
+
+// /*
+// ** Warning-related functions
+// */
+
+//void (lua_setwarnf) (State *L, lua_WarnFunction f, void *ud);
+//void (lua_warning)  (State *L, const char *msg, int tocont);
+
+// /*
+// ** garbage-collection function and options
+// */
+
+const (
+	GCSTOP       = 0
+	GCRESTART    = 1
+	GCCOLLECT    = 2
+	GCCOUNT      = 3
+	GCCOUNTB     = 4
+	GCSTEP       = 5
+	GCSETPAUSE   = 6
+	GCSETSTEPMUL = 7
+	GCISRUNNING  = 9
+	GCGEN        = 10
+	GCINC        = 11
+)
+
+// LUA_API int (lua_gc) (State *L, int what, ...);
+
+// /*
+// ** miscellaneous functions
+// */
+// llgo:link (*State).Next C.lua_next
+func (L *State) Next(idx c.Int) c.Int { return 0 }
+
+// LUA_API int   (lua_error) (State *L);
+
+// LUA_API void  (lua_concat) (State *L, int n);
+// LUA_API void  (lua_len)    (State *L, int idx);
+
+// LUA_API size_t   (lua_stringtonumber) (State *L, const char *s);
+
+// LUA_API lua_Alloc (lua_getallocf) (State *L, void **ud);
+// LUA_API void      (lua_setallocf) (State *L, lua_Alloc f, void *ud);
+
+// LUA_API void (lua_toclose) (State *L, int idx);
+// LUA_API void (lua_closeslot) (State *L, int idx);
+
+// /*
+// ** {==============================================================
+// ** some useful macros
+// ** ===============================================================
+// */
+
+// #define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+func (L *State) Tonumber(idx c.Int) Number   { return L.Tonumberx(idx, nil) }
+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) 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) }
+func (L *State) Isnil(n c.Int) bool           { return L.Type(n) == c.Int(NIL) }
+func (L *State) Isboolean(n c.Int) bool       { return L.Type(n) == c.Int(BOOLEAN) }
+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_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))
+
+// /* }============================================================== */
+
+// /*
+// ** {==============================================================
+// ** compatibility macros
+// ** ===============================================================
+// */
+
+// #define lua_newuserdata(L,s)	lua_newuserdatauv(L,s,1)
+// #define lua_getuservalue(L,idx)	lua_getiuservalue(L,idx,1)
+// #define lua_setuservalue(L,idx)	lua_setiuservalue(L,idx,1)
+
+// #define LUA_NUMTAGS		LUA_NUMTYPES
+
+// /* }============================================================== */
+
+// /*
+// ** {======================================================================
+// ** Debug API
+// ** =======================================================================
+// */
+// /*
+// ** Event codes
+// */
+
+const (
+	HOOKCALL     = 0
+	HOOKRET      = 1
+	HOOKLINE     = 2
+	HOOKCOUNT    = 3
+	HOOKTAILCALL = 4
+)
+
+// /*
+// ** Event masks
+// */
+// #define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+// #define LUA_MASKRET	(1 << LUA_HOOKRET)
+// #define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+// #define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+const (
+	MASKCALL  = 1 << HOOKCOUNT
+	MASKRET   = 1 << HOOKRET
+	MASKLINE  = 1 << HOOKLINE
+	MASKCOUNT = 1 << HOOKCOUNT
+)
+
+// LUA_API int (lua_getstack) (State *L, int level, lua_Debug *ar);
+// LUA_API int (lua_getinfo) (State *L, const char *what, lua_Debug *ar);
+// LUA_API const char *(lua_getlocal) (State *L, const lua_Debug *ar, int n);
+// LUA_API const char *(lua_setlocal) (State *L, const lua_Debug *ar, int n);
+// LUA_API const char *(lua_getupvalue) (State *L, int funcindex, int n);
+// LUA_API const char *(lua_setupvalue) (State *L, int funcindex, int n);
+
+// LUA_API void *(lua_upvalueid) (State *L, int fidx, int n);
+// LUA_API void  (lua_upvaluejoin) (State *L, int fidx1, int n1, int fidx2, int n2);
+
+// LUA_API void (lua_sethook) (State *L, lua_Hook func, int mask, int count);
+// LUA_API lua_Hook (lua_gethook) (State *L);
+// LUA_API int (lua_gethookmask) (State *L);
+// LUA_API int (lua_gethookcount) (State *L);
+
+// LUA_API int (lua_setcstacklimit) (State *L, unsigned int limit);
+
+// struct lua_Debug
+// /* }====================================================================== */

c/lua/lualib.go

@@ -0,0 +1,8 @@
+package lua
+
+import (
+	_ "unsafe"
+)
+
+// llgo:link (*State).Openlibs C.luaL_openlibs
+func (L *State) Openlibs() {}

c/neco/README.md

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