Merge pull request #536 from xushiwei/x

doc How-to-migrate-a-C&C++-Library

.github/workflows/go.yml

@@ -5,24 +5,25 @@ name: Go
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "*" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "*" ]
 
 jobs:
 
   test:
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
-        llvm: [17]
+        # os: [macos-latest, ubuntu-latest]
+        os: [macos-latest]
+        llvm: [18]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
 
       - name: Update Homebrew
-        # needed as long as LLVM 17 is still fresh
-        if: matrix.llvm == 17 && startsWith(matrix.os, 'macos')
+        # needed as long as LLVM 18 is still fresh
+        if: matrix.llvm == 18 && startsWith(matrix.os, 'macos')
         run: brew update
       - name: Install LLVM ${{ matrix.llvm }} and bdw-gc
         if: startsWith(matrix.os, 'macos')

.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

@@ -8,7 +8,7 @@ for d in ./_demo/* ./_pydemo/*; do
   total=$((total+1))
   if [ -d "$d" ]; then
     echo "Testing $d"
-    if ! llgo run -v "$d"; then
+    if ! llgo run "$d"; then
       echo "FAIL"
       failed=$((failed+1))
       failed_cases="$failed_cases\n* :x: $d"

.github/workflows/test_llgo.sh

@@ -4,7 +4,7 @@ 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

@@ -19,6 +19,7 @@ numpy.txt
 _go/
 _runtime/
 _tinygo/
+_output/
 build.dir/
 .vscode/
 
@@ -34,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/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/xtool/env.buildDate={{.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/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/xtool/env.buildDate={{.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/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/xtool/env.buildDate={{.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/xtool/env.buildVersion=v{{.Version}}
+      - -X github.com/goplus/llgo/xtool/env.buildDate={{.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

@@ -10,8 +10,41 @@ llgo - A Go compiler based on LLVM
 
 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](https://github.com/goplus/gop).
 
+LLGo aims to expand the boundaries of Go/Go+, providing limitless possibilities such as:
 
-## C standard libary support
+* Game development
+* AI and data science
+* WebAssembly
+* Embedded development
+* ...
+
+How can these be achieved?
+
+```
+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/C++ standard libary support
+
+You can import a C/C++ standard library in LLGo!
+
+* [c](https://pkg.go.dev/github.com/goplus/llgo/c)
+* [c/os](https://pkg.go.dev/github.com/goplus/llgo/c/os)
+* [c/syscall](https://pkg.go.dev/github.com/goplus/llgo/c/syscall)
+* [c/math](https://pkg.go.dev/github.com/goplus/llgo/c/math)
+* [c/math/cmplx](https://pkg.go.dev/github.com/goplus/llgo/c/math/cmplx)
+* [c/math/rand](https://pkg.go.dev/github.com/goplus/llgo/c/math/rand)
+* [c/pthread](https://pkg.go.dev/github.com/goplus/llgo/c/pthread)
+* [c/pthread/sync](https://pkg.go.dev/github.com/goplus/llgo/c/pthread/sync)
+* [c/sync/atomic](https://pkg.go.dev/github.com/goplus/llgo/c/sync/atomic)
+* [c/time](https://pkg.go.dev/github.com/goplus/llgo/c/time)
+* [c/socket](https://pkg.go.dev/github.com/goplus/llgo/c/socket)
+* [cpp/std](https://pkg.go.dev/github.com/goplus/llgo/cpp/std)
+
+Here is a simple example:
 
 ```go
 package main
@@ -38,7 +71,44 @@ cd <demo-directory>  # eg. cd _demo/hello
 llgo run .
 ```
 
-See [github.com/goplus/llgo/c](https://pkg.go.dev/github.com/goplus/llgo/c) for more detials.
+
+## 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
@@ -47,38 +117,48 @@ You can import a Python library in LLGo!
 
 And you can import any Python library into `llgo` through a program called `llpyg` (see [Development tools](#development-tools)). The following libraries have been included in `llgo`:
 
-* [builtins](https://pkg.go.dev/github.com/goplus/llgo/py/std)
-* [sys](https://pkg.go.dev/github.com/goplus/llgo/py/sys)
-* [os](https://pkg.go.dev/github.com/goplus/llgo/py/os)
-* [math](https://pkg.go.dev/github.com/goplus/llgo/py/math)
-* [json](https://pkg.go.dev/github.com/goplus/llgo/py/json)
-* [inspect](https://pkg.go.dev/github.com/goplus/llgo/py/inspect)
-* [statistics](https://pkg.go.dev/github.com/goplus/llgo/py/statistics)
-* [numpy](https://pkg.go.dev/github.com/goplus/llgo/py/numpy)
-* [pandas](https://pkg.go.dev/github.com/goplus/llgo/py/pandas)
-* [pytorch](https://pkg.go.dev/github.com/goplus/llgo/py/torch)
-* [matplotlib](https://pkg.go.dev/github.com/goplus/llgo/py/matplotlib)
+* [py](https://pkg.go.dev/github.com/goplus/llgo/py) (abi)
+* [py/std](https://pkg.go.dev/github.com/goplus/llgo/py/std) (builtins)
+* [py/sys](https://pkg.go.dev/github.com/goplus/llgo/py/sys)
+* [py/os](https://pkg.go.dev/github.com/goplus/llgo/py/os)
+* [py/math](https://pkg.go.dev/github.com/goplus/llgo/py/math)
+* [py/json](https://pkg.go.dev/github.com/goplus/llgo/py/json)
+* [py/inspect](https://pkg.go.dev/github.com/goplus/llgo/py/inspect)
+* [py/statistics](https://pkg.go.dev/github.com/goplus/llgo/py/statistics)
+* [py/numpy](https://pkg.go.dev/github.com/goplus/llgo/py/numpy)
+* [py/pandas](https://pkg.go.dev/github.com/goplus/llgo/py/pandas)
+* [py/torch](https://pkg.go.dev/github.com/goplus/llgo/py/torch)
+* [py/matplotlib](https://pkg.go.dev/github.com/goplus/llgo/py/matplotlib)
 
 Note: For third-party libraries (such as pandas and pytorch), you still need to install the library files.
 
-Here is an example using the Python `math` library:
+Here is an example:
 
 ```go
 package main
 
 import (
-	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/py"
 	"github.com/goplus/llgo/py/math"
+	"github.com/goplus/llgo/py/std"
 )
 
 func main() {
-	x := math.Sqrt(py.Float(2))
-	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+	x := math.Sqrt(py.Float(2))       // x = sqrt(2)
+	std.Print(py.Str("sqrt(2) ="), x) // print("sqrt(2) =", x)
 }
 ```
 
-Here, We call `py.Float(2)` to create a Python number 2, and pass it to Python’s `math.sqrt` to get `x`. Then use `x.Float64()` to convert x to Go's `float64` type, and print the value through the C `printf` function.
+It is equivalent to the following Python code:
+
+```py
+import math
+
+x = math.sqrt(2)
+print("sqrt =", x)
+```
+
+Here, We call `py.Float(2)` to create a Python number 2, and pass it to Python’s `math.sqrt` to get `x`. Then we call `std.Print` to print the result.
 
 Let's look at a slightly more complex example. For example, we use `numpy` to calculate:
 
@@ -86,9 +166,9 @@ Let's look at a slightly more complex example. For example, we use `numpy` to ca
 package main
 
 import (
-	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/py"
 	"github.com/goplus/llgo/py/numpy"
+	"github.com/goplus/llgo/py/std"
 )
 
 func main() {
@@ -103,7 +183,7 @@ func main() {
 		py.List(3.0, 2.0, 1.0),
 	)
 	x := numpy.Add(a, b)
-	c.Printf(c.Str("a+b = %s\n"), x.Str().CStr())
+	std.Print(py.Str("a+b ="), x)
 }
 ```
 
@@ -116,37 +196,13 @@ The `_pydemo` directory contains some python related demos:
 * [statistics](_pydemo/statistics/statistics.go): define a python list and call `statistics.mean` to get the mean
 * [matrix](_pydemo/matrix/matrix.go): a basic `numpy` demo
 
-To run these demos, you need to set the `LLGO_LIB_PYTHON` environment variable first.
-
-If Python is in the search path for `clang` linking, then `LLGO_LIB_PYTHON` only needs to be set to the name of the Python library. For example:
-
-```sh
-export LLGO_LIB_PYTHON=python3.12
-```
-
-You can also specify the path to tell `llgo` where the Python library is located:
-
-```sh
-export LLGO_LIB_PYTHON=/foo/bar/python3.12
-```
-
-For example, `/opt/homebrew/Frameworks/Python.framework/Versions/3.12/lib/libpython3.12.dylib` is a typical python library location under macOS. So we should set it like this:
-
-```sh
-export LLGO_LIB_PYTHON=/opt/homebrew/Frameworks/Python.framework/Versions/3.12/lib/python3.12
-```
-
-Note that the file name must be written in a platform-independent format, using `python3.12` instead of `libpython3.12.dylib`.
-
-Then you can run the demos:
+To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
 
 ```sh
 cd <demo-directory>  # eg. cd _pydemo/callpy
 llgo run .
 ```
 
-See [github.com/goplus/llgo/py](https://pkg.go.dev/github.com/goplus/llgo/py) for more detials.
-
 
 ## Other frequently used libraries
 
@@ -154,25 +210,28 @@ LLGo can easily import any libraries from the C ecosystem. Currently, this impor
 
 The currently supported libraries include:
 
-* [llama2.c](https://pkg.go.dev/github.com/goplus/llgo/c/llama2)
-* [cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson)
-* [sqlite](https://pkg.go.dev/github.com/goplus/llgo/c/sqlite)
+* [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/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/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)
 
 Here are some examples related to them:
 
 * [llama2-c](_demo/llama2-c): inference Llama 2 (It's the first llgo AI example)
 * [mkjson](c/cjson/_demo/mkjson/mkjson.go): create a json object and print it
 * [sqlitedemo](c/sqlite/_demo/sqlitedemo/demo.go): a basic sqlite demo
+* [tetris](c/raylib/_demo/tetris/tetris.go): a tetris game based on raylib
 
 
 ## Go syntax support
 
-Common Go syntax is already supported. Except for the following, which needs to be improved:
-
-* map (Very limited support)
-* chan (Not supported yet)
-
-Here are some examples related to Go syntax:
+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)
@@ -208,26 +267,37 @@ Here are the Go packages that can be imported correctly:
 * [math](https://pkg.go.dev/math)
 * [math/bits](https://pkg.go.dev/math/bits)
 * [math/cmplx](https://pkg.go.dev/math/cmplx)
+* [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)
+* [log](https://pkg.go.dev/log)
+* [flag](https://pkg.go.dev/flag)
 * [sort](https://pkg.go.dev/sort)
 * [strconv](https://pkg.go.dev/strconv)
+* [strings](https://pkg.go.dev/strings)
 * [sync/atomic](https://pkg.go.dev/sync/atomic)
 * [sync](https://pkg.go.dev/sync) (partially)
 * [syscall](https://pkg.go.dev/syscall) (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)
 
 
 ## Dependencies
 
 - [Go 1.20+](https://go.dev) (build only)
-- [LLVM 17](https://llvm.org)
-- [LLD 17](https://lld.llvm.org)
-- [Clang 17](https://clang.llvm.org)
+- [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))
+- [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))
 
 ## How to install
 
@@ -237,30 +307,22 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 
 ```sh
 brew update # execute if needed
-brew install llvm@17 pkg-config libgc
+brew install llvm@18 pkg-config libgc
 brew install cjson sqlite python@3.12 # optional
-export PATH=$(brew --prefix llvm@17)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
-export CC=clang CXX=clang++ # only for go build; optional if you have other compatible compilers
-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 ./...
+export PATH=$(brew --prefix llvm@18)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
 ### on Linux (Debian/Ubuntu)
 
 ```sh
-echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-17 main" | sudo tee /etc/apt/sources.list.d/llvm.list
+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-17-dev clang-17 lld-17 pkg-config libgc-dev
+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-17/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
-export CC=clang CXX=clang++ # only for go build; optional if you have other compatible compilers
-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 ./...
+export PATH=/usr/lib/llvm-18/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
 ### on Windows
@@ -279,8 +341,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/_chandemo/chan.go

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+	c1 := make(chan string)
+	c2 := make(chan string, 1)
+	go func() {
+		c1 <- "ch1"
+	}()
+	go func() {
+		c2 <- "ch2"
+	}()
+
+	for i := 0; i < 2; i++ {
+		select {
+		case msg1 := <-c1:
+			println(msg1)
+		case msg2 := <-c2:
+			println(msg2)
+		}
+	}
+}

_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(10 * time.Second):
+		fmt.Println("timed out")
+	}
+}

_cmptest/chan/chan.go

@@ -0,0 +1,11 @@
+package main
+
+func main() {
+	ch := make(chan int, 10)
+	println(len(ch), cap(ch))
+	go func() {
+		ch <- 100
+	}()
+	n, ok := <-ch
+	println(n, ok)
+}

_cmptest/chansel/chansel.go

@@ -0,0 +1,26 @@
+package main
+
+func fibonacci(c, quit chan int) {
+	x, y := 0, 1
+	for {
+		select {
+		case c <- x:
+			x, y = y, x+y
+		case <-quit:
+			println("quit")
+			return
+		}
+	}
+}
+
+func main() {
+	c := make(chan int)
+	quit := make(chan int)
+	go func() {
+		for i := 0; i < 10; i++ {
+			println(<-c)
+		}
+		close(quit)
+	}()
+	fibonacci(c, quit)
+}

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

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Hello, world")
+	fmt.Printf("%f\n", 3.14)
+	fmt.Printf("%v\n", errors.New("error message"))
+}

_cmptest/iodemo/io.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"io"
+	"os"
+)
+
+func f(w io.Writer) {
+	w.Write([]byte("Hello, world\n"))
+}
+
+func main() {
+	f(os.Stdout)
+}

_cmptest/osdemo/osd.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"os"
+)
+
+func main() {
+	home, _ := os.UserHomeDir()
+	println("home:", home)
+
+	cfgdir, _ := os.UserConfigDir()
+	println("cfgdir:", cfgdir)
+
+	cache, _ := os.UserCacheDir()
+	println("cachedir:", cache)
+
+	os.Stdout.Write([]byte("Hello, World\n"))
+}

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

@@ -0,0 +1,8 @@
+package main
+
+import "time"
+
+func main() {
+	t := time.Date(2018, time.January, 1, 2, 3, 4, 5, time.UTC)
+	println(t.String())
+}

_demo/cchan/cchan.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/internal/runtime"
+)
+
+const (
+	eltSize = int(unsafe.Sizeof(0))
+)
+
+func doChan(cap int) {
+	c := runtime.NewChan(eltSize, cap)
+	go func() {
+		v := 100
+		runtime.ChanSend(c, unsafe.Pointer(&v), eltSize)
+	}()
+	var ret int
+	runtime.ChanRecv(c, unsafe.Pointer(&ret), eltSize)
+	println(ret)
+}
+
+func main() {
+	doChan(10)
+	doChan(0)
+
+	c := runtime.NewChan(eltSize, 3)
+
+	v := 1
+	runtime.ChanSend(c, unsafe.Pointer(&v), eltSize)
+	v = 2
+	runtime.ChanSend(c, unsafe.Pointer(&v), eltSize)
+	v = 3
+	runtime.ChanSend(c, unsafe.Pointer(&v), eltSize)
+	runtime.ChanClose(c)
+
+	v = 10
+
+	if runtime.ChanTrySend(c, unsafe.Pointer(&v), eltSize) {
+		println("error: chan send to closed chan")
+	}
+
+	for {
+		if ok := runtime.ChanRecv(c, unsafe.Pointer(&v), eltSize); !ok {
+			break
+		}
+		println(v)
+	}
+}

_demo/cchansel/cchansel.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/internal/runtime"
+)
+
+const (
+	eltSize = int(unsafe.Sizeof(0))
+)
+
+func fibonacci(c, quit *runtime.Chan) {
+	x, y := 0, 1
+	for {
+		isel, _ := runtime.Select(
+			runtime.ChanOp{C: c, Send: true, Val: unsafe.Pointer(&x), Size: int32(eltSize)},
+			runtime.ChanOp{C: quit},
+		)
+		if isel == 0 {
+			x, y = y, x+y
+		} else {
+			println("quit")
+			return
+		}
+	}
+}
+
+func main() {
+	c := runtime.NewChan(eltSize, 0)
+	quit := runtime.NewChan(eltSize, 0)
+	go func() {
+		for i := 0; i < 10; i++ {
+			val := 0
+			runtime.ChanRecv(c, unsafe.Pointer(&val), eltSize)
+			println(val)
+		}
+		runtime.ChanClose(quit)
+	}()
+	fibonacci(c, quit)
+}

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

@@ -8,10 +8,10 @@ import (
 
 type Bar struct {
 	foo.Callback
-	a int
+	a c.Int
 }
 
-func NewBar(a int) *Bar {
+func NewBar(a c.Int) *Bar {
 	return &Bar{
 		Callback: foo.Callback{
 			Vptr: &foo.CallbackVtbl{
@@ -23,7 +23,7 @@ func NewBar(a int) *Bar {
 	}
 }
 
-func (p *Bar) getA() int {
+func (p *Bar) getA() c.Int {
 	return p.a
 }
 

_demo/cppmintf/cpp_multi_intf.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/_demo/cppmintf/foo"
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/math"
+)
+
+type Bar struct {
+	foo.Callback
+	a c.Int
+}
+
+func NewBar(a c.Int) *Bar {
+	return &Bar{
+		Callback: foo.Callback{
+			ICalc: foo.ICalc{
+				Vptr: &foo.ICalcVtbl{
+					Calc: c.Func((*Bar).sqrt),
+				},
+			},
+			IVal: foo.IVal{
+				Vptr: &foo.IValVtbl{
+					Val: c.Func(bar_IVal_getA),
+				},
+			},
+		},
+		a: a,
+	}
+}
+
+func (p *Bar) getA() c.Int {
+	return p.a
+}
+
+func bar_IVal_getA(this c.Pointer) c.Int {
+	const delta = -int(unsafe.Offsetof(foo.Callback{}.IVal))
+	return (*Bar)(c.Advance(this, delta)).getA()
+}
+
+func (p *Bar) sqrt(v float64) float64 {
+	return math.Sqrt(v)
+}
+
+func main() {
+	bar := NewBar(1)
+	foo.F(&bar.Callback)
+}

_demo/cppmintf/foo/bar/bar.cpp

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#define interface struct
+
+interface ICalc {
+	virtual double calc(double v) = 0;
+};
+
+interface IVal {
+	virtual int val() = 0;
+};
+
+class Callback : public ICalc, public IVal {
+};
+
+extern "C" void f(Callback* cb) {
+	printf("val: %d\ncalc(2): %lf\n", cb->val(), cb->calc(2));
+}

_demo/cppmintf/foo/foo.go

@@ -0,0 +1,42 @@
+package foo
+
+import (
+	"unsafe"
+)
+
+const (
+	LLGoFiles   = "bar/bar.cpp"
+	LLGoPackage = "link"
+)
+
+// -----------------------------------------------------------------------------
+
+type ICalc struct {
+	Vptr *ICalcVtbl
+}
+
+type ICalcVtbl struct {
+	Calc unsafe.Pointer
+}
+
+// -----------------------------------------------------------------------------
+
+type IVal struct {
+	Vptr *IValVtbl
+}
+
+type IValVtbl struct {
+	Val unsafe.Pointer
+}
+
+// -----------------------------------------------------------------------------
+
+type Callback struct {
+	ICalc
+	IVal
+}
+
+//go:linkname F C.f
+func F(cb *Callback)
+
+// -----------------------------------------------------------------------------

_demo/ctime/time.go

@@ -0,0 +1,12 @@
+package main
+
+import "github.com/goplus/llgo/c/time"
+
+func main() {
+	var tv time.Timespec
+	time.ClockGettime(time.CLOCK_REALTIME, &tv)
+	println("REALTIME sec:", tv.Sec, "nsec:", tv.Nsec)
+
+	time.ClockGettime(time.CLOCK_MONOTONIC, &tv)
+	println("MONOTONIC sec:", tv.Sec, "nsec:", tv.Nsec)
+}

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

@@ -0,0 +1,7 @@
+package main
+
+import "time"
+
+func main() {
+	println(time.Now().String())
+}

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

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

_demo/osexec/exec.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+	"runtime"
+)
+
+func main() {
+	ls := "ls"
+	if runtime.GOOS == "windows" {
+		ls = "dir"
+	}
+	cmd := exec.Command(ls)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Run()
+}

_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

@@ -0,0 +1,15 @@
+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/socket/client/client.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+	"github.com/goplus/llgo/c/socket"
+)
+
+func main() {
+	sockfd := socket.Socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+	msg := c.Str("Hello, World!")
+	defer os.Close(sockfd)
+
+	server := socket.GetHostByName(c.Str("localhost"))
+	if server == nil {
+		c.Perror(c.Str("hostname get error"))
+		return
+	}
+
+	servAddr := &socket.SockaddrIn{}
+	servAddr.Family = socket.AF_INET
+	servAddr.Port = socket.Htons(uint16(1234))
+	c.Memcpy(unsafe.Pointer(&servAddr.Addr.Addr), unsafe.Pointer(*server.AddrList), uintptr(server.Length))
+
+	if res := socket.Connect(sockfd, (*socket.SockAddr)(unsafe.Pointer(servAddr)), c.Uint(16)); res < 0 {
+		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/os"
+	"github.com/goplus/llgo/c/socket"
+)
+
+func main() {
+	var buffer [256]c.Char
+
+	sockfd := socket.Socket(socket.AF_INET, socket.SOCK_STREAM, 0)
+	defer os.Close(sockfd)
+
+	servAddr := &socket.SockaddrIn{
+		Family: socket.AF_INET,
+		Port:   socket.Htons(uint16(1234)),
+		Addr:   socket.InAddr{Addr: 0x00000000},
+		Zero:   [8]c.Char{0, 0, 0, 0, 0, 0, 0, 0},
+	}
+	if res := socket.Bind(sockfd, servAddr, c.Uint(unsafe.Sizeof(*servAddr))); res < 0 {
+		c.Perror(c.Str("bind error"))
+		return
+	}
+
+	if socket.Listen(sockfd, 5) < 0 {
+		c.Printf(c.Str("listen error"))
+		return
+	}
+	c.Printf(c.Str("Listening on port 1234...\n"))
+
+	cliAddr, clilen := &socket.SockaddrIn{}, c.Uint(unsafe.Sizeof(servAddr))
+
+	newsockfd := socket.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))
+}

_pydemo/callpy/callpy.go

@@ -1,12 +1,12 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/py"
 	"github.com/goplus/llgo/py/math"
+	"github.com/goplus/llgo/py/std"
 )
 
 func main() {
-	x := math.Sqrt(py.Float(2))
-	c.Printf(c.Str("sqrt(2) = %f\n"), x.Float64())
+	x := math.Sqrt(py.Float(2))       // x = sqrt(2)
+	std.Print(py.Str("sqrt(2) ="), x) // print("sqrt(2) =", x)
 }

_pydemo/matrix/matrix.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"github.com/goplus/llgo/c"
 	"github.com/goplus/llgo/py"
 	"github.com/goplus/llgo/py/numpy"
+	"github.com/goplus/llgo/py/std"
 )
 
 func main() {
@@ -18,5 +18,5 @@ func main() {
 		py.List(3.0, 2.0, 1.0),
 	)
 	x := numpy.Add(a, b)
-	c.Printf(c.Str("a+b = %s\n"), x.Str().CStr())
+	std.Print(py.Str("a+b ="), x)
 }

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

@@ -17,6 +17,9 @@
 package c
 
 // typedef unsigned int uint;
+// typedef unsigned long ulong;
+// typedef unsigned long long ulonglong;
+// typedef long long longlong;
 import "C"
 import "unsafe"
 
@@ -25,20 +28,22 @@ const (
 )
 
 type (
-	Char      = int8
-	Long      = int32
-	Ulong     = uint32
-	LongLong  = int64
-	UlongLong = uint64
-	Float     = float32
-	Double    = float64
-	Pointer   = unsafe.Pointer
-	FilePtr   = unsafe.Pointer
+	Char    = int8
+	Float   = float32
+	Double  = float64
+	Pointer = unsafe.Pointer
+	FilePtr = unsafe.Pointer
 )
 
 type (
 	Int  C.int
 	Uint C.uint
+
+	Long  C.long
+	Ulong C.ulong
+
+	LongLong  C.longlong
+	UlongLong C.ulonglong
 )
 
 type integer interface {
@@ -63,6 +68,13 @@ 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 }
+
 //go:linkname Malloc C.malloc
 func Malloc(size uintptr) Pointer
 
@@ -203,6 +215,15 @@ 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 Fclose C.fclose
+func Fclose(fp FilePtr) Int
+
+//go:linkname Perror C.perror
+func Perror(s *Char)
+
 // -----------------------------------------------------------------------------
 
 //go:linkname Time C.time

c/clang/_demo/castdump/astdump.go

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

c/clang/_wrap/cursor.cpp

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <clang-c/Index.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);
+}
+
+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

@@ -0,0 +1,59 @@
+/*
+ * 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 clang
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+/**
+ * A character string.
+ *
+ * The \c CXString type is used to return strings from the interface when
+ * the ownership of that string might differ from one call to the next.
+ * Use \c clang_getCString() to retrieve the string data and, once finished
+ * with the string data, call \c clang_disposeString() to free the string.
+ */
+type String struct {
+	Data         c.Pointer
+	PrivateFlags c.Uint
+}
+
+/**
+ * Retrieve the character data associated with the given string.
+ */
+// llgo:link String.CStr C.clang_getCString
+func (String) CStr() *c.Char { return nil }
+
+/**
+ * Free the given string.
+ */
+// llgo:link String.Dispose C.clang_disposeString
+func (String) Dispose() {}
+
+type StringSet struct {
+	Strings *String
+	Count   c.Uint
+}
+
+/**
+ * Free the given string set.
+ */
+// llgo:link (*StringSet).Dispose C.clang_disposeStringSet
+func (*StringSet) Dispose() {}

c/clang/clang.go

@@ -0,0 +1,292 @@
+/*
+ * 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 clang
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoFiles   = "$(llvm-config --cflags): _wrap/cursor.cpp"
+	LLGoPackage = "link: -L$(llvm-config --libdir) -lclang; -lclang"
+)
+
+/**
+ * Opaque pointer representing client data that will be passed through
+ * to various callbacks and visitors.
+ */
+type ClientData = c.Pointer
+
+/**
+ * Provides the contents of a file that has not yet been saved to disk.
+ *
+ * Each CXUnsavedFile instance provides the name of a file on the
+ * system along with the current contents of that file that have not
+ * yet been saved to disk.
+ */
+type UnsavedFile struct {
+	/**
+	 * The file whose contents have not yet been saved.
+	 *
+	 * This file must already exist in the file system.
+	 */
+	Filename *c.Char
+
+	/**
+	 * A buffer containing the unsaved contents of this file.
+	 */
+	Contents *c.Char
+
+	/**
+	 * The length of the unsaved contents of this buffer.
+	 */
+	Length c.Ulong
+}
+
+/**
+ * An "index" that consists of a set of translation units that would
+ * typically be linked together into an executable or library.
+ */
+type Index struct {
+	Unused [0]byte
+}
+
+/**
+ * Provides a shared context for creating translation units.
+ *
+ * It provides two options:
+ *
+ * - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local"
+ * declarations (when loading any new translation units). A "local" declaration
+ * is one that belongs in the translation unit itself and not in a precompiled
+ * header that was used by the translation unit. If zero, all declarations
+ * will be enumerated.
+ *
+ * Here is an example:
+ *
+ * \code
+ *   // excludeDeclsFromPCH = 1, displayDiagnostics=1
+ *   Idx = clang_createIndex(1, 1);
+ *
+ *   // IndexTest.pch was produced with the following command:
+ *   // "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
+ *   TU = clang_createTranslationUnit(Idx, "IndexTest.pch");
+ *
+ *   // This will load all the symbols from 'IndexTest.pch'
+ *   clang_visitChildren(clang_getTranslationUnitCursor(TU),
+ *                       TranslationUnitVisitor, 0);
+ *   clang_disposeTranslationUnit(TU);
+ *
+ *   // This will load all the symbols from 'IndexTest.c', excluding symbols
+ *   // from 'IndexTest.pch'.
+ *   char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" };
+ *   TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
+ *                                                  0, 0);
+ *   clang_visitChildren(clang_getTranslationUnitCursor(TU),
+ *                       TranslationUnitVisitor, 0);
+ *   clang_disposeTranslationUnit(TU);
+ * \endcode
+ *
+ * This process of creating the 'pch', loading it separately, and using it (via
+ * -include-pch) allows 'excludeDeclsFromPCH' to remove redundant callbacks
+ * (which gives the indexer the same performance benefit as the compiler).
+ */
+//go:linkname CreateIndex C.clang_createIndex
+func CreateIndex(excludeDeclarationsFromPCH, displayDiagnostics c.Int) *Index
+
+/**
+ * Destroy the given index.
+ *
+ * The index must not be destroyed until all of the translation units created
+ * within that index have been destroyed.
+ */
+// llgo:link (*Index).Dispose C.clang_disposeIndex
+func (*Index) Dispose() {}
+
+/**
+ * Flags that control the creation of translation units.
+ *
+ * The enumerators in this enumeration type are meant to be bitwise
+ * ORed together to specify which options should be used when
+ * constructing the translation unit.
+ */
+const (
+	TranslationUnit_None = 0x0
+)
+
+/**
+ * Same as \c clang_parseTranslationUnit2, but returns
+ * the \c CXTranslationUnit instead of an error code.  In case of an error this
+ * routine returns a \c NULL \c CXTranslationUnit, without further detailed
+ * error codes.
+ */
+// llgo:link (*Index).ParseTranslationUnit C.clang_parseTranslationUnit
+func (*Index) ParseTranslationUnit(
+	sourceFilename *c.Char, commandLineArgs **c.Char, numCommandLineArgs c.Int,
+	unsavedFiles *UnsavedFile, numUnsavedFiles c.Uint, options c.Uint) *TranslationUnit {
+	return nil
+}
+
+/**
+ * A single translation unit, which resides in an index.
+ */
+type TranslationUnit struct {
+	Unused [0]byte
+}
+
+/**
+ * Destroy the specified CXTranslationUnit object.
+ */
+// llgo:link (*TranslationUnit).Dispose C.clang_disposeTranslationUnit
+func (*TranslationUnit) Dispose() {}
+
+/**
+ * Retrieve the cursor that represents the given translation unit.
+ *
+ * The translation unit cursor can be used to start traversing the
+ * various declarations within the given translation unit.
+ */
+// llgo:link (*TranslationUnit).Cursor C.clang_getTranslationUnitCursor
+func (*TranslationUnit) Cursor() (ret Cursor) {
+	return
+}
+
+/**
+ * Describes the kind of entity that a cursor refers to.
+ */
+type CursorKind c.Int
+
+/* for debug/testing */
+// llgo:link CursorKind.String C.clang_getCursorKindSpelling
+func (CursorKind) String() (ret String) {
+	return
+}
+
+/**
+ * A cursor representing some element in the abstract syntax tree for
+ * a translation unit.
+ *
+ * The cursor abstraction unifies the different kinds of entities in a
+ * program--declaration, statements, expressions, references to declarations,
+ * etc.--under a single "cursor" abstraction with a common set of operations.
+ * Common operation for a cursor include: getting the physical location in
+ * a source file where the cursor points, getting the name associated with a
+ * cursor, and retrieving cursors for any child nodes of a particular cursor.
+ *
+ * Cursors can be produced in two specific ways.
+ * clang_getTranslationUnitCursor() produces a cursor for a translation unit,
+ * from which one can use clang_visitChildren() to explore the rest of the
+ * translation unit. clang_getCursor() maps from a physical source location
+ * to the entity that resides at that location, allowing one to map from the
+ * source code into the AST.
+ */
+type Cursor struct {
+	Kind  CursorKind
+	Xdata c.Int
+	Data  [3]c.Pointer
+}
+
+/**
+ * Retrieve a name for the entity referenced by this cursor.
+ */
+// llgo:link (*Cursor).wrapString C.wrap_clang_getCursorSpelling
+func (*Cursor) wrapString() (ret String) {
+	return
+}
+
+func (c Cursor) String() (ret String) {
+	return c.wrapString()
+}
+
+/**
+ * Describes how the traversal of the children of a particular
+ * cursor should proceed after visiting a particular child cursor.
+ *
+ * A value of this enumeration type should be returned by each
+ * \c CXCursorVisitor to indicate how clang_visitChildren() proceed.
+ */
+type ChildVisitResult c.Int
+
+const (
+	/**
+	 * Terminates the cursor traversal.
+	 */
+	ChildVisit_Break ChildVisitResult = iota
+	/**
+	 * Continues the cursor traversal with the next sibling of
+	 * the cursor just visited, without visiting its children.
+	 */
+	ChildVisit_Continue
+	/**
+	 * Recursively traverse the children of this cursor, using
+	 * the same visitor and client data.
+	 */
+	ChildVisit_Recurse
+)
+
+/**
+ * Visit the children of a particular cursor.
+ *
+ * This function visits all the direct children of the given cursor,
+ * invoking the given \p visitor function with the cursors of each
+ * visited child. The traversal may be recursive, if the visitor returns
+ * \c CXChildVisit_Recurse. The traversal may also be ended prematurely, if
+ * the visitor returns \c CXChildVisit_Break.
+ *
+ * \param parent the cursor whose child may be visited. All kinds of
+ * cursors can be visited, including invalid cursors (which, by
+ * definition, have no children).
+ *
+ * \param visitor the visitor function that will be invoked for each
+ * child of \p parent.
+ *
+ * \param client_data pointer data supplied by the client, which will
+ * be passed to the visitor each time it is invoked.
+ *
+ * \returns a non-zero value if the traversal was terminated
+ * prematurely by the visitor returning \c CXChildVisit_Break.
+ */
+//go:linkname wrapVisitChildren C.wrap_clang_visitChildren
+func wrapVisitChildren(
+	cusor *Cursor,
+	fn wrapVisitor,
+	clientData ClientData) c.Uint {
+	return 0
+}
+
+//llgo:type C
+type wrapVisitor func(cursor, parent *Cursor, clientData ClientData) ChildVisitResult
+
+type wrapData struct {
+	data ClientData
+	fn   Visitor
+}
+
+func VisitChildren(
+	root Cursor,
+	fn Visitor,
+	clientData ClientData) c.Uint {
+	return wrapVisitChildren(&root, func(cursor, parent *Cursor, data ClientData) ChildVisitResult {
+		p := (*wrapData)(data)
+		return p.fn(*cursor, *parent, p.data)
+	}, unsafe.Pointer(&wrapData{clientData, fn}))
+}
+
+//llgo:type C
+type Visitor func(cursor, parent Cursor, clientData ClientData) ChildVisitResult

c/llama2/README.md

@@ -0,0 +1,10 @@
+LLGo wrapper of karpathy/llama2.c
+=====
+
+## How to update source to llgo
+
+```
+git submodule init
+git submodule update
+cp llama2.c/run.c llama2/run.c
+```

c/llama2/llama2.go

@@ -23,7 +23,8 @@ import (
 )
 
 const (
-	LLGoPackage = "link"
+	LLGoFiles   = "llama2/llama2.c"
+	LLGoPackage = "link: -lm"
 )
 
 // -----------------------------------------------------------------------------

c/llama2/llama2/llama2.c

@@ -0,0 +1,2 @@
+#define TESTING
+#include "./run.c"

c/llama2/llama2/run.c

@@ -1,2 +1,973 @@
-#define TESTING
-#include "../llama2.c/run.c"
+/* Inference for Llama-2 Transformer model in pure C */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <time.h>
+#include <math.h>
+#include <string.h>
+#include <fcntl.h>
+#if defined _WIN32
+    #include "win.h"
+#else
+    #include <unistd.h>
+    #include <sys/mman.h>
+#endif
+// ----------------------------------------------------------------------------
+// Transformer model
+
+typedef struct {
+    int dim; // transformer dimension
+    int hidden_dim; // for ffn layers
+    int n_layers; // number of layers
+    int n_heads; // number of query heads
+    int n_kv_heads; // number of key/value heads (can be < query heads because of multiquery)
+    int vocab_size; // vocabulary size, usually 256 (byte-level)
+    int seq_len; // max sequence length
+} Config;
+
+typedef struct {
+    // token embedding table
+    float* token_embedding_table;    // (vocab_size, dim)
+    // weights for rmsnorms
+    float* rms_att_weight; // (layer, dim) rmsnorm weights
+    float* rms_ffn_weight; // (layer, dim)
+    // weights for matmuls. note dim == n_heads * head_size
+    float* wq; // (layer, dim, n_heads * head_size)
+    float* wk; // (layer, dim, n_kv_heads * head_size)
+    float* wv; // (layer, dim, n_kv_heads * head_size)
+    float* wo; // (layer, n_heads * head_size, dim)
+    // weights for ffn
+    float* w1; // (layer, hidden_dim, dim)
+    float* w2; // (layer, dim, hidden_dim)
+    float* w3; // (layer, hidden_dim, dim)
+    // final rmsnorm
+    float* rms_final_weight; // (dim,)
+    // (optional) classifier weights for the logits, on the last layer
+    float* wcls;
+} TransformerWeights;
+
+typedef struct {
+    // current wave of activations
+    float *x; // activation at current time stamp (dim,)
+    float *xb; // same, but inside a residual branch (dim,)
+    float *xb2; // an additional buffer just for convenience (dim,)
+    float *hb; // buffer for hidden dimension in the ffn (hidden_dim,)
+    float *hb2; // buffer for hidden dimension in the ffn (hidden_dim,)
+    float *q; // query (dim,)
+    float *k; // key (dim,)
+    float *v; // value (dim,)
+    float *att; // buffer for scores/attention values (n_heads, seq_len)
+    float *logits; // output logits
+    // kv cache
+    float* key_cache;   // (layer, seq_len, dim)
+    float* value_cache; // (layer, seq_len, dim)
+} RunState;
+
+typedef struct {
+    Config config; // the hyperparameters of the architecture (the blueprint)
+    TransformerWeights weights; // the weights of the model
+    RunState state; // buffers for the "wave" of activations in the forward pass
+    // some more state needed to properly clean up the memory mapping (sigh)
+    int fd; // file descriptor for memory mapping
+    float* data; // memory mapped data pointer
+    ssize_t file_size; // size of the checkpoint file in bytes
+} Transformer;
+
+void malloc_run_state(RunState* s, Config* p) {
+    // we calloc instead of malloc to keep valgrind happy
+    int kv_dim = (p->dim * p->n_kv_heads) / p->n_heads;
+    s->x = calloc(p->dim, sizeof(float));
+    s->xb = calloc(p->dim, sizeof(float));
+    s->xb2 = calloc(p->dim, sizeof(float));
+    s->hb = calloc(p->hidden_dim, sizeof(float));
+    s->hb2 = calloc(p->hidden_dim, sizeof(float));
+    s->q = calloc(p->dim, sizeof(float));
+    s->key_cache = calloc(p->n_layers * p->seq_len * kv_dim, sizeof(float));
+    s->value_cache = calloc(p->n_layers * p->seq_len * kv_dim, sizeof(float));
+    s->att = calloc(p->n_heads * p->seq_len, sizeof(float));
+    s->logits = calloc(p->vocab_size, sizeof(float));
+    // ensure all mallocs went fine
+    if (!s->x || !s->xb || !s->xb2 || !s->hb || !s->hb2 || !s->q
+     || !s->key_cache || !s->value_cache || !s->att || !s->logits) {
+        fprintf(stderr, "malloc failed!\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void free_run_state(RunState* s) {
+    free(s->x);
+    free(s->xb);
+    free(s->xb2);
+    free(s->hb);
+    free(s->hb2);
+    free(s->q);
+    free(s->att);
+    free(s->logits);
+    free(s->key_cache);
+    free(s->value_cache);
+}
+
+void memory_map_weights(TransformerWeights *w, Config* p, float* ptr, int shared_weights) {
+    int head_size = p->dim / p->n_heads;
+    // make sure the multiplications below are done in 64bit to fit the parameter counts of 13B+ models
+    unsigned long long n_layers = p->n_layers;
+    w->token_embedding_table = ptr;
+    ptr += p->vocab_size * p->dim;
+    w->rms_att_weight = ptr;
+    ptr += n_layers * p->dim;
+    w->wq = ptr;
+    ptr += n_layers * p->dim * (p->n_heads * head_size);
+    w->wk = ptr;
+    ptr += n_layers * p->dim * (p->n_kv_heads * head_size);
+    w->wv = ptr;
+    ptr += n_layers * p->dim * (p->n_kv_heads * head_size);
+    w->wo = ptr;
+    ptr += n_layers * (p->n_heads * head_size) * p->dim;
+    w->rms_ffn_weight = ptr;
+    ptr += n_layers * p->dim;
+    w->w1 = ptr;
+    ptr += n_layers * p->dim * p->hidden_dim;
+    w->w2 = ptr;
+    ptr += n_layers * p->hidden_dim * p->dim;
+    w->w3 = ptr;
+    ptr += n_layers * p->dim * p->hidden_dim;
+    w->rms_final_weight = ptr;
+    ptr += p->dim;
+    ptr += p->seq_len * head_size / 2; // skip what used to be freq_cis_real (for RoPE)
+    ptr += p->seq_len * head_size / 2; // skip what used to be freq_cis_imag (for RoPE)
+    w->wcls = shared_weights ? w->token_embedding_table : ptr;
+}
+
+void read_checkpoint(char* checkpoint, Config* config, TransformerWeights* weights,
+                     int* fd, float** data, ssize_t* file_size) {
+    FILE *file = fopen(checkpoint, "rb");
+    if (!file) { fprintf(stderr, "Couldn't open file %s\n", checkpoint); exit(EXIT_FAILURE); }
+    // read in the config header
+    if (fread(config, sizeof(Config), 1, file) != 1) { exit(EXIT_FAILURE); }
+    // negative vocab size is hacky way of signaling unshared weights. bit yikes.
+    int shared_weights = config->vocab_size > 0 ? 1 : 0;
+    config->vocab_size = abs(config->vocab_size);
+    // figure out the file size
+    fseek(file, 0, SEEK_END); // move file pointer to end of file
+    *file_size = ftell(file); // get the file size, in bytes
+    fclose(file);
+    // memory map the Transformer weights into the data pointer
+    *fd = open(checkpoint, O_RDONLY); // open in read only mode
+    if (*fd == -1) { fprintf(stderr, "open failed!\n"); exit(EXIT_FAILURE); }
+    *data = mmap(NULL, *file_size, PROT_READ, MAP_PRIVATE, *fd, 0);
+    if (*data == MAP_FAILED) { fprintf(stderr, "mmap failed!\n"); exit(EXIT_FAILURE); }
+    float* weights_ptr = *data + sizeof(Config)/sizeof(float);
+    memory_map_weights(weights, config, weights_ptr, shared_weights);
+}
+
+void build_transformer(Transformer *t, char* checkpoint_path) {
+    // read in the Config and the Weights from the checkpoint
+    read_checkpoint(checkpoint_path, &t->config, &t->weights, &t->fd, &t->data, &t->file_size);
+    // allocate the RunState buffers
+    malloc_run_state(&t->state, &t->config);
+}
+
+void free_transformer(Transformer* t) {
+    // close the memory mapping
+    if (t->data != MAP_FAILED) { munmap(t->data, t->file_size); }
+    if (t->fd != -1) { close(t->fd); }
+    // free the RunState buffers
+    free_run_state(&t->state);
+}
+
+// ----------------------------------------------------------------------------
+// neural net blocks; the dynamics of the Transformer
+
+void rmsnorm(float* o, float* x, float* weight, int size) {
+    // calculate sum of squares
+    float ss = 0.0f;
+    for (int j = 0; j < size; j++) {
+        ss += x[j] * x[j];
+    }
+    ss /= size;
+    ss += 1e-5f;
+    ss = 1.0f / sqrtf(ss);
+    // normalize and scale
+    for (int j = 0; j < size; j++) {
+        o[j] = weight[j] * (ss * x[j]);
+    }
+}
+
+void softmax(float* x, int size) {
+    // find max value (for numerical stability)
+    float max_val = x[0];
+    for (int i = 1; i < size; i++) {
+        if (x[i] > max_val) {
+            max_val = x[i];
+        }
+    }
+    // exp and sum
+    float sum = 0.0f;
+    for (int i = 0; i < size; i++) {
+        x[i] = expf(x[i] - max_val);
+        sum += x[i];
+    }
+    // normalize
+    for (int i = 0; i < size; i++) {
+        x[i] /= sum;
+    }
+}
+
+void matmul(float* xout, float* x, float* w, int n, int d) {
+    // W (d,n) @ x (n,) -> xout (d,)
+    // by far the most amount of time is spent inside this little function
+    int i;
+    #pragma omp parallel for private(i)
+    for (i = 0; i < d; i++) {
+        float val = 0.0f;
+        for (int j = 0; j < n; j++) {
+            val += w[i * n + j] * x[j];
+        }
+        xout[i] = val;
+    }
+}
+
+float* forward(Transformer* transformer, int token, int pos) {
+
+    // a few convenience variables
+    Config* p = &transformer->config;
+    TransformerWeights* w = &transformer->weights;
+    RunState* s = &transformer->state;
+    float *x = s->x;
+    int dim = p->dim;
+    int kv_dim = (p->dim * p->n_kv_heads) / p->n_heads;
+    int kv_mul = p->n_heads / p->n_kv_heads; // integer multiplier of the kv sharing in multiquery
+    int hidden_dim =  p->hidden_dim;
+    int head_size = dim / p->n_heads;
+
+    // copy the token embedding into x
+    float* content_row = w->token_embedding_table + token * dim;
+    memcpy(x, content_row, dim*sizeof(*x));
+
+    // forward all the layers
+    for(unsigned long long l = 0; l < p->n_layers; l++) {
+
+        // attention rmsnorm
+        rmsnorm(s->xb, x, w->rms_att_weight + l*dim, dim);
+
+        // key and value point to the kv cache
+        int loff = l * p->seq_len * kv_dim; // kv cache layer offset for convenience
+        s->k = s->key_cache + loff + pos * kv_dim;
+        s->v = s->value_cache + loff + pos * kv_dim;
+
+        // qkv matmuls for this position
+        matmul(s->q, s->xb, w->wq + l*dim*dim, dim, dim);
+        matmul(s->k, s->xb, w->wk + l*dim*kv_dim, dim, kv_dim);
+        matmul(s->v, s->xb, w->wv + l*dim*kv_dim, dim, kv_dim);
+
+        // RoPE relative positional encoding: complex-valued rotate q and k in each head
+        for (int i = 0; i < dim; i+=2) {
+            int head_dim = i % head_size;
+            float freq = 1.0f / powf(10000.0f, head_dim / (float)head_size);
+            float val = pos * freq;
+            float fcr = cosf(val);
+            float fci = sinf(val);
+            int rotn = i < kv_dim ? 2 : 1; // how many vectors? 2 = q & k, 1 = q only
+            for (int v = 0; v < rotn; v++) {
+                float* vec = v == 0 ? s->q : s->k; // the vector to rotate (query or key)
+                float v0 = vec[i];
+                float v1 = vec[i+1];
+                vec[i]   = v0 * fcr - v1 * fci;
+                vec[i+1] = v0 * fci + v1 * fcr;
+            }
+        }
+
+        // multihead attention. iterate over all heads
+        int h;
+        #pragma omp parallel for private(h)
+        for (h = 0; h < p->n_heads; h++) {
+            // get the query vector for this head
+            float* q = s->q + h * head_size;
+            // attention scores for this head
+            float* att = s->att + h * p->seq_len;
+            // iterate over all timesteps, including the current one
+            for (int t = 0; t <= pos; t++) {
+                // get the key vector for this head and at this timestep
+                float* k = s->key_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
+                // calculate the attention score as the dot product of q and k
+                float score = 0.0f;
+                for (int i = 0; i < head_size; i++) {
+                    score += q[i] * k[i];
+                }
+                score /= sqrtf(head_size);
+                // save the score to the attention buffer
+                att[t] = score;
+            }
+
+            // softmax the scores to get attention weights, from 0..pos inclusively
+            softmax(att, pos + 1);
+
+            // weighted sum of the values, store back into xb
+            float* xb = s->xb + h * head_size;
+            memset(xb, 0, head_size * sizeof(float));
+            for (int t = 0; t <= pos; t++) {
+                // get the value vector for this head and at this timestep
+                float* v = s->value_cache + loff + t * kv_dim + (h / kv_mul) * head_size;
+                // get the attention weight for this timestep
+                float a = att[t];
+                // accumulate the weighted value into xb
+                for (int i = 0; i < head_size; i++) {
+                    xb[i] += a * v[i];
+                }
+            }
+        }
+
+        // final matmul to get the output of the attention
+        matmul(s->xb2, s->xb, w->wo + l*dim*dim, dim, dim);
+
+        // residual connection back into x
+        for (int i = 0; i < dim; i++) {
+            x[i] += s->xb2[i];
+        }
+
+        // ffn rmsnorm
+        rmsnorm(s->xb, x, w->rms_ffn_weight + l*dim, dim);
+
+        // Now for FFN in PyTorch we have: self.w2(F.silu(self.w1(x)) * self.w3(x))
+        // first calculate self.w1(x) and self.w3(x)
+        matmul(s->hb, s->xb, w->w1 + l*dim*hidden_dim, dim, hidden_dim);
+        matmul(s->hb2, s->xb, w->w3 + l*dim*hidden_dim, dim, hidden_dim);
+
+        // SwiGLU non-linearity
+        for (int i = 0; i < hidden_dim; i++) {
+            float val = s->hb[i];
+            // silu(x)=x*σ(x), where σ(x) is the logistic sigmoid
+            val *= (1.0f / (1.0f + expf(-val)));
+            // elementwise multiply with w3(x)
+            val *= s->hb2[i];
+            s->hb[i] = val;
+        }
+
+        // final matmul to get the output of the ffn
+        matmul(s->xb, s->hb, w->w2 + l*dim*hidden_dim, hidden_dim, dim);
+
+        // residual connection
+        for (int i = 0; i < dim; i++) {
+            x[i] += s->xb[i];
+        }
+    }
+
+    // final rmsnorm
+    rmsnorm(x, x, w->rms_final_weight, dim);
+
+    // classifier into logits
+    matmul(s->logits, x, w->wcls, p->dim, p->vocab_size);
+    return s->logits;
+}
+
+// ----------------------------------------------------------------------------
+// The Byte Pair Encoding (BPE) Tokenizer that translates strings <-> tokens
+
+typedef struct {
+    char *str;
+    int id;
+} TokenIndex;
+
+typedef struct {
+    char** vocab;
+    float* vocab_scores;
+    TokenIndex *sorted_vocab;
+    int vocab_size;
+    unsigned int max_token_length;
+    unsigned char byte_pieces[512]; // stores all single-byte strings
+} Tokenizer;
+
+int compare_tokens(const void *a, const void *b) {
+    return strcmp(((TokenIndex*)a)->str, ((TokenIndex*)b)->str);
+}
+
+void build_tokenizer(Tokenizer* t, char* tokenizer_path, int vocab_size) {
+    // i should have written the vocab_size into the tokenizer file... sigh
+    t->vocab_size = vocab_size;
+    // malloc space to hold the scores and the strings
+    t->vocab = (char**)malloc(vocab_size * sizeof(char*));
+    t->vocab_scores = (float*)malloc(vocab_size * sizeof(float));
+    t->sorted_vocab = NULL; // initialized lazily
+    for (int i = 0; i < 256; i++) {
+        t->byte_pieces[i * 2] = (unsigned char)i;
+        t->byte_pieces[i * 2 + 1] = '\0';
+    }
+    // read in the file
+    FILE *file = fopen(tokenizer_path, "rb");
+    if (!file) { fprintf(stderr, "couldn't load %s\n", tokenizer_path); exit(EXIT_FAILURE); }
+    if (fread(&t->max_token_length, sizeof(int), 1, file) != 1) { fprintf(stderr, "failed read\n"); exit(EXIT_FAILURE); }
+    int len;
+    for (int i = 0; i < vocab_size; i++) {
+        if (fread(t->vocab_scores + i, sizeof(float), 1, file) != 1) { fprintf(stderr, "failed read\n"); exit(EXIT_FAILURE);}
+        if (fread(&len, sizeof(int), 1, file) != 1) { fprintf(stderr, "failed read\n"); exit(EXIT_FAILURE); }
+        t->vocab[i] = (char *)malloc(len + 1);
+        if (fread(t->vocab[i], len, 1, file) != 1) { fprintf(stderr, "failed read\n"); exit(EXIT_FAILURE); }
+        t->vocab[i][len] = '\0'; // add the string terminating token
+    }
+    fclose(file);
+}
+
+void free_tokenizer(Tokenizer* t) {
+    for (int i = 0; i < t->vocab_size; i++) { free(t->vocab[i]); }
+    free(t->vocab);
+    free(t->vocab_scores);
+    free(t->sorted_vocab);
+}
+
+char* decode(Tokenizer* t, int prev_token, int token) {
+    char *piece = t->vocab[token];
+    // following BOS (1) token, sentencepiece decoder strips any leading whitespace (see PR #89)
+    if (prev_token == 1 && piece[0] == ' ') { piece++; }
+    // careful, some tokens designate raw bytes, and look like e.g. '<0x01>'
+    // parse this and convert and return the actual byte
+    unsigned char byte_val;
+    if (sscanf(piece, "<0x%02hhX>", &byte_val) == 1) {
+        piece = (char*)t->byte_pieces + byte_val * 2;
+    }
+    return piece;
+}
+
+void safe_printf(char *piece) {
+    // piece might be a raw byte token, and we only want to print printable chars or whitespace
+    // because some of the other bytes can be various control codes, backspace, etc.
+    if (piece == NULL) { return; }
+    if (piece[0] == '\0') { return; }
+    if (piece[1] == '\0') {
+        unsigned char byte_val = piece[0];
+        if (!(isprint(byte_val) || isspace(byte_val))) {
+            return; // bad byte, don't print it
+        }
+    }
+    printf("%s", piece);
+}
+
+int str_lookup(char *str, TokenIndex *sorted_vocab, int vocab_size) {
+    // efficiently find the perfect match for str in vocab, return its index or -1 if not found
+    TokenIndex tok = { .str = str }; // acts as the key to search for
+    TokenIndex *res = bsearch(&tok, sorted_vocab, vocab_size, sizeof(TokenIndex), compare_tokens);
+    return res != NULL ? res->id : -1;
+}
+
+void encode(Tokenizer* t, char *text, int8_t bos, int8_t eos, int *tokens, int *n_tokens) {
+    // encode the string text (input) into an upper-bound preallocated tokens[] array
+    // bos != 0 means prepend the BOS token (=1), eos != 0 means append the EOS token (=2)
+    if (text == NULL) { fprintf(stderr, "cannot encode NULL text\n"); exit(EXIT_FAILURE); }
+
+    if (t->sorted_vocab == NULL) {
+        // lazily malloc and sort the vocabulary
+        t->sorted_vocab = malloc(t->vocab_size * sizeof(TokenIndex));
+        for (int i = 0; i < t->vocab_size; i++) {
+            t->sorted_vocab[i].str = t->vocab[i];
+            t->sorted_vocab[i].id = i;
+        }
+        qsort(t->sorted_vocab, t->vocab_size, sizeof(TokenIndex), compare_tokens);
+    }
+
+    // create a temporary buffer that will store merge candidates of always two consecutive tokens
+    // *2 for concat, +1 for null terminator +2 for UTF8 (in case max_token_length is 1)
+    char* str_buffer = malloc((t->max_token_length*2 +1 +2) * sizeof(char));
+    size_t str_len = 0;
+
+    // start at 0 tokens
+    *n_tokens = 0;
+
+    // add optional BOS (=1) token, if desired
+    if (bos) tokens[(*n_tokens)++] = 1;
+
+    // add_dummy_prefix is true by default
+    // so prepend a dummy prefix token to the input string, but only if text != ""
+    // TODO: pretty sure this isn't correct in the general case but I don't have the
+    // energy to read more of the sentencepiece code to figure out what it's doing
+    if (text[0] != '\0') {
+        int dummy_prefix = str_lookup(" ", t->sorted_vocab, t->vocab_size);
+        tokens[(*n_tokens)++] = dummy_prefix;
+    }
+
+    // Okay UTF-8 time. This will get messy. Here is the reference from Wikipedia:
+    // Code point ↔ UTF-8 conversion
+    // First code point	Last code point	Byte 1	Byte 2	Byte 3	Byte 4
+    // U+0000	U+007F	    0xxxxxxx
+    // U+0080	U+07FF	    110xxxxx	10xxxxxx
+    // U+0800	U+FFFF	    1110xxxx	10xxxxxx	10xxxxxx
+    // U+10000	U+10FFFF    11110xxx	10xxxxxx	10xxxxxx	10xxxxxx
+
+    // process the raw (UTF-8) byte sequence of the input string
+    for (char *c = text; *c != '\0'; c++) {
+
+        // reset buffer if the current byte is ASCII or a leading byte
+        // 0xC0 is 11000000, so (*c & 0xC0) keeps the first 2 bits and zeros the rest
+        // 0x80 is 10000000
+        // in UTF-8, all continuation bytes start with "10" in first two bits
+        // so in English this is: "if this byte is not a continuation byte"
+        if ((*c & 0xC0) != 0x80) {
+            // this byte must be either a leading byte (11...) or an ASCII char (0x...)
+            // => reset our location, as we're starting a new UTF-8 codepoint
+            str_len = 0;
+        }
+
+        // append the current byte to the buffer
+        str_buffer[str_len++] = *c; // ++ is post-increment, incremented after this line
+        str_buffer[str_len] = '\0';
+
+        // while the next character is a continuation byte, continue appending
+        // but if there are too many of them, just stop to avoid overruning str_buffer size.
+        if ((*(c+1) & 0xC0) == 0x80 && str_len < 4) {
+            continue;
+        }
+
+        // ok c+1 is not a continuation byte, so we've read in a full codepoint
+        int id = str_lookup(str_buffer, t->sorted_vocab, t->vocab_size);
+
+        if (id != -1) {
+            // we found this codepoint in vocab, add it as a token
+            tokens[(*n_tokens)++] = id;
+        } else {
+            // byte_fallback encoding: just encode each byte as a token
+            // +3 is here because the first 3 vocab elements are <unk>, <s>, </s>
+            // so the individual bytes only start at index 3
+            for (int i=0; i < str_len; i++) {
+                tokens[(*n_tokens)++] = (unsigned char)str_buffer[i] + 3;
+            }
+        }
+        str_len = 0; // protect against a sequence of stray UTF8 continuation bytes
+    }
+
+    // merge the best consecutive pair each iteration, according the scores in vocab_scores
+    while (1) {
+        float best_score = -1e10;
+        int best_id = -1;
+        int best_idx = -1;
+
+        for (int i=0; i < (*n_tokens-1); i++) {
+            // check if we can merge the pair (tokens[i], tokens[i+1])
+            sprintf(str_buffer, "%s%s", t->vocab[tokens[i]], t->vocab[tokens[i+1]]);
+            int id = str_lookup(str_buffer, t->sorted_vocab, t->vocab_size);
+            if (id != -1 && t->vocab_scores[id] > best_score) {
+                // this merge pair exists in vocab! record its score and position
+                best_score = t->vocab_scores[id];
+                best_id = id;
+                best_idx = i;
+            }
+        }
+
+        if (best_idx == -1) {
+            break; // we couldn't find any more pairs to merge, so we're done
+        }
+
+        // merge the consecutive pair (best_idx, best_idx+1) into new token best_id
+        tokens[best_idx] = best_id;
+        // delete token at position best_idx+1, shift the entire sequence back 1
+        for (int i = best_idx+1; i < (*n_tokens-1); i++) {
+            tokens[i] = tokens[i+1];
+        }
+        (*n_tokens)--; // token length decreased
+    }
+
+    // add optional EOS (=2) token, if desired
+    if (eos) tokens[(*n_tokens)++] = 2;
+
+    free(str_buffer);
+}
+
+// ----------------------------------------------------------------------------
+// The Sampler, which takes logits and returns a sampled token
+// sampling can be done in a few ways: greedy argmax, sampling, top-p sampling
+
+typedef struct {
+    float prob;
+    int index;
+} ProbIndex; // struct used when sorting probabilities during top-p sampling
+
+typedef struct {
+    int vocab_size;
+    ProbIndex* probindex; // buffer used in top-p sampling
+    float temperature;
+    float topp;
+    unsigned long long rng_state;
+} Sampler;
+
+int sample_argmax(float* probabilities, int n) {
+    // return the index that has the highest probability
+    int max_i = 0;
+    float max_p = probabilities[0];
+    for (int i = 1; i < n; i++) {
+        if (probabilities[i] > max_p) {
+            max_i = i;
+            max_p = probabilities[i];
+        }
+    }
+    return max_i;
+}
+
+int sample_mult(float* probabilities, int n, float coin) {
+    // sample index from probabilities (they must sum to 1!)
+    // coin is a random number in [0, 1), usually from random_f32()
+    float cdf = 0.0f;
+    for (int i = 0; i < n; i++) {
+        cdf += probabilities[i];
+        if (coin < cdf) {
+            return i;
+        }
+    }
+    return n - 1; // in case of rounding errors
+}
+
+int compare(const void* a, const void* b) {
+    ProbIndex* a_ = (ProbIndex*) a;
+    ProbIndex* b_ = (ProbIndex*) b;
+    if (a_->prob > b_->prob) return -1;
+    if (a_->prob < b_->prob) return 1;
+    return 0;
+}
+
+int sample_topp(float* probabilities, int n, float topp, ProbIndex* probindex, float coin) {
+    // top-p sampling (or "nucleus sampling") samples from the smallest set of
+    // tokens that exceed probability topp. This way we never sample tokens that
+    // have very low probabilities and are less likely to go "off the rails".
+    // coin is a random number in [0, 1), usually from random_f32()
+
+    int n0 = 0;
+    // quicksort indices in descending order of probabilities
+    // values smaller than (1 - topp) / (n - 1) cannot be part of the result
+    // so for efficiency we crop these out as candidates before sorting
+    const float cutoff = (1.0f - topp) / (n - 1);
+    for (int i = 0; i < n; i++) {
+        if (probabilities[i] >= cutoff) {
+            probindex[n0].index = i;
+            probindex[n0].prob = probabilities[i];
+            n0++;
+        }
+    }
+    qsort(probindex, n0, sizeof(ProbIndex), compare);
+
+    // truncate the list where cumulative probability exceeds topp
+    float cumulative_prob = 0.0f;
+    int last_idx = n0 - 1; // in case of rounding errors consider all elements
+    for (int i = 0; i < n0; i++) {
+        cumulative_prob += probindex[i].prob;
+        if (cumulative_prob > topp) {
+            last_idx = i;
+            break; // we've exceeded topp by including last_idx
+        }
+    }
+
+    // sample from the truncated list
+    float r = coin * cumulative_prob;
+    float cdf = 0.0f;
+    for (int i = 0; i <= last_idx; i++) {
+        cdf += probindex[i].prob;
+        if (r < cdf) {
+            return probindex[i].index;
+        }
+    }
+    return probindex[last_idx].index; // in case of rounding errors
+}
+
+void build_sampler(Sampler* sampler, int vocab_size, float temperature, float topp, unsigned long long rng_seed) {
+    sampler->vocab_size = vocab_size;
+    sampler->temperature = temperature;
+    sampler->topp = topp;
+    sampler->rng_state = rng_seed;
+    // buffer only used with nucleus sampling; may not need but it's ~small
+    sampler->probindex = malloc(sampler->vocab_size * sizeof(ProbIndex));
+}
+
+void free_sampler(Sampler* sampler) {
+    free(sampler->probindex);
+}
+
+unsigned int random_u32(unsigned long long *state) {
+    // xorshift rng: https://en.wikipedia.org/wiki/Xorshift#xorshift.2A
+    *state ^= *state >> 12;
+    *state ^= *state << 25;
+    *state ^= *state >> 27;
+    return (*state * 0x2545F4914F6CDD1Dull) >> 32;
+}
+float random_f32(unsigned long long *state) { // random float32 in [0,1)
+    return (random_u32(state) >> 8) / 16777216.0f;
+}
+
+int sample(Sampler* sampler, float* logits) {
+    // sample the token given the logits and some hyperparameters
+    int next;
+    if (sampler->temperature == 0.0f) {
+        // greedy argmax sampling: take the token with the highest probability
+        next = sample_argmax(logits, sampler->vocab_size);
+    } else {
+        // apply the temperature to the logits
+        for (int q=0; q<sampler->vocab_size; q++) { logits[q] /= sampler->temperature; }
+        // apply softmax to the logits to get the probabilities for next token
+        softmax(logits, sampler->vocab_size);
+        // flip a (float) coin (this is our source of entropy for sampling)
+        float coin = random_f32(&sampler->rng_state);
+        // we sample from this distribution to get the next token
+        if (sampler->topp <= 0 || sampler->topp >= 1) {
+            // simply sample from the predicted probability distribution
+            next = sample_mult(logits, sampler->vocab_size, coin);
+        } else {
+            // top-p (nucleus) sampling, clamping the least likely tokens to zero
+            next = sample_topp(logits, sampler->vocab_size, sampler->topp, sampler->probindex, coin);
+        }
+    }
+    return next;
+}
+
+// ----------------------------------------------------------------------------
+// utilities: time
+
+long time_in_ms() {
+    // return time in milliseconds, for benchmarking the model speed
+    struct timespec time;
+    clock_gettime(CLOCK_REALTIME, &time);
+    return time.tv_sec * 1000 + time.tv_nsec / 1000000;
+}
+
+// ----------------------------------------------------------------------------
+// generation loop
+
+void generate(Transformer *transformer, Tokenizer *tokenizer, Sampler *sampler, char *prompt, int steps) {
+    char *empty_prompt = "";
+    if (prompt == NULL) { prompt = empty_prompt; }
+
+    // encode the (string) prompt into tokens sequence
+    int num_prompt_tokens = 0;
+    int* prompt_tokens = (int*)malloc((strlen(prompt)+3) * sizeof(int)); // +3 for '\0', ?BOS, ?EOS
+    encode(tokenizer, prompt, 1, 0, prompt_tokens, &num_prompt_tokens);
+    if (num_prompt_tokens < 1) {
+        fprintf(stderr, "something is wrong, expected at least 1 prompt token\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // start the main loop
+    long start = 0;  // used to time our code, only initialized after first iteration
+    int next;        // will store the next token in the sequence
+    int token = prompt_tokens[0]; // kick off with the first token in the prompt
+    int pos = 0;     // position in the sequence
+    while (pos < steps) {
+
+        // forward the transformer to get logits for the next token
+        float* logits = forward(transformer, token, pos);
+
+        // advance the state machine
+        if (pos < num_prompt_tokens - 1) {
+            // if we are still processing the input prompt, force the next prompt token
+            next = prompt_tokens[pos + 1];
+        } else {
+            // otherwise sample the next token from the logits
+            next = sample(sampler, logits);
+        }
+        pos++;
+
+        // data-dependent terminating condition: the BOS (=1) token delimits sequences
+        if (next == 1) { break; }
+
+        // print the token as string, decode it with the Tokenizer object
+        char* piece = decode(tokenizer, token, next);
+        safe_printf(piece); // same as printf("%s", piece), but skips "unsafe" bytes
+        fflush(stdout);
+        token = next;
+
+        // init the timer here because the first iteration can be slower
+        if (start == 0) { start = time_in_ms(); }
+    }
+    printf("\n");
+
+    // report achieved tok/s (pos-1 because the timer starts after first iteration)
+    if (pos > 1) {
+        long end = time_in_ms();
+        fprintf(stderr, "achieved tok/s: %f\n", (pos-1) / (double)(end-start)*1000);
+    }
+
+    free(prompt_tokens);
+}
+
+void read_stdin(const char* guide, char* buffer, size_t bufsize) {
+    // read a line from stdin, up to but not including \n
+    printf("%s", guide);
+    if (fgets(buffer, bufsize, stdin) != NULL) {
+        size_t len = strlen(buffer);
+        if (len > 0 && buffer[len - 1] == '\n') {
+            buffer[len - 1] = '\0'; // strip newline
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+// chat loop
+// I manually inspected the tokens for a few chat conversations compared to
+// python reference and that seemed ok, but this was not thoroughly tested and
+// is not safely implemented, it's more a proof of concept atm.
+
+void chat(Transformer *transformer, Tokenizer *tokenizer, Sampler *sampler,
+          char *cli_user_prompt, char *cli_system_prompt, int steps) {
+
+    // buffers for reading the system prompt and user prompt from stdin
+    // you'll notice they are soomewhat haphazardly and unsafely set atm
+    char system_prompt[512];
+    char user_prompt[512];
+    char rendered_prompt[1152];
+    int num_prompt_tokens = 0;
+    int* prompt_tokens = (int*)malloc(1152 * sizeof(int));
+    int user_idx;
+
+    // start the main loop
+    int8_t user_turn = 1; // user starts
+    int next;        // will store the next token in the sequence
+    int token;       // stores the current token to feed into the transformer
+    int prev_token;
+    int pos = 0;     // position in the sequence
+    while (pos < steps) {
+
+        // when it is the user's turn to contribute tokens to the dialog...
+        if (user_turn) {
+            // get the (optional) system prompt at position 0
+            if (pos == 0) {
+                // at position 0, the user can also contribute a system prompt
+                if (cli_system_prompt == NULL) {
+                    // system prompt was not passed in, attempt to get it from stdin
+                    read_stdin("Enter system prompt (optional): ", system_prompt, sizeof(system_prompt));
+                } else {
+                    // system prompt was passed in, use it
+                    strcpy(system_prompt, cli_system_prompt);
+                }
+            }
+            // get the user prompt
+            if (pos == 0 && cli_user_prompt != NULL) {
+                // user prompt for position 0 was passed in, use it
+                strcpy(user_prompt, cli_user_prompt);
+            } else {
+                // otherwise get user prompt from stdin
+                read_stdin("User: ", user_prompt, sizeof(user_prompt));
+            }
+            // render user/system prompts into the Llama 2 Chat schema
+            if (pos == 0 && system_prompt[0] != '\0') {
+                char system_template[] = "[INST] <<SYS>>\n%s\n<</SYS>>\n\n%s [/INST]";
+                sprintf(rendered_prompt, system_template, system_prompt, user_prompt);
+            } else {
+                char user_template[] = "[INST] %s [/INST]";
+                sprintf(rendered_prompt, user_template, user_prompt);
+            }
+            // encode the rendered prompt into tokens
+            encode(tokenizer, rendered_prompt, 1, 0, prompt_tokens, &num_prompt_tokens);
+            user_idx = 0; // reset the user index
+            user_turn = 0;
+            printf("Assistant: ");
+        }
+
+        // determine the token to pass into the transformer next
+        if (user_idx < num_prompt_tokens) {
+            // if we are still processing the input prompt, force the next prompt token
+            token = prompt_tokens[user_idx++];
+        } else {
+            // otherwise use the next token sampled from previous turn
+            token = next;
+        }
+        // EOS (=2) token ends the Assistant turn
+        if (token == 2) { user_turn = 1; }
+
+        // forward the transformer to get logits for the next token
+        float* logits = forward(transformer, token, pos);
+        next = sample(sampler, logits);
+        pos++;
+
+        if (user_idx >= num_prompt_tokens && next != 2) {
+            // the Assistant is responding, so print its output
+            char* piece = decode(tokenizer, token, next);
+            safe_printf(piece); // same as printf("%s", piece), but skips "unsafe" bytes
+            fflush(stdout);
+        }
+        if (next == 2) { printf("\n"); }
+    }
+    printf("\n");
+    free(prompt_tokens);
+}
+
+
+// ----------------------------------------------------------------------------
+// CLI, include only if not testing
+#ifndef TESTING
+
+void error_usage() {
+    fprintf(stderr, "Usage:   run <checkpoint> [options]\n");
+    fprintf(stderr, "Example: run model.bin -n 256 -i \"Once upon a time\"\n");
+    fprintf(stderr, "Options:\n");
+    fprintf(stderr, "  -t <float>  temperature in [0,inf], default 1.0\n");
+    fprintf(stderr, "  -p <float>  p value in top-p (nucleus) sampling in [0,1] default 0.9\n");
+    fprintf(stderr, "  -s <int>    random seed, default time(NULL)\n");
+    fprintf(stderr, "  -n <int>    number of steps to run for, default 256. 0 = max_seq_len\n");
+    fprintf(stderr, "  -i <string> input prompt\n");
+    fprintf(stderr, "  -z <string> optional path to custom tokenizer\n");
+    fprintf(stderr, "  -m <string> mode: generate|chat, default: generate\n");
+    fprintf(stderr, "  -y <string> (optional) system prompt in chat mode\n");
+    exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[]) {
+
+    // default parameters
+    char *checkpoint_path = NULL;  // e.g. out/model.bin
+    char *tokenizer_path = "tokenizer.bin";
+    float temperature = 1.0f;   // 0.0 = greedy deterministic. 1.0 = original. don't set higher
+    float topp = 0.9f;          // top-p in nucleus sampling. 1.0 = off. 0.9 works well, but slower
+    int steps = 256;            // number of steps to run for
+    char *prompt = NULL;        // prompt string
+    unsigned long long rng_seed = 0; // seed rng with time by default
+    char *mode = "generate";    // generate|chat
+    char *system_prompt = NULL; // the (optional) system prompt to use in chat mode
+
+    // poor man's C argparse so we can override the defaults above from the command line
+    if (argc >= 2) { checkpoint_path = argv[1]; } else { error_usage(); }
+    for (int i = 2; i < argc; i+=2) {
+        // do some basic validation
+        if (i + 1 >= argc) { error_usage(); } // must have arg after flag
+        if (argv[i][0] != '-') { error_usage(); } // must start with dash
+        if (strlen(argv[i]) != 2) { error_usage(); } // must be -x (one dash, one letter)
+        // read in the args
+        if (argv[i][1] == 't') { temperature = atof(argv[i + 1]); }
+        else if (argv[i][1] == 'p') { topp = atof(argv[i + 1]); }
+        else if (argv[i][1] == 's') { rng_seed = atoi(argv[i + 1]); }
+        else if (argv[i][1] == 'n') { steps = atoi(argv[i + 1]); }
+        else if (argv[i][1] == 'i') { prompt = argv[i + 1]; }
+        else if (argv[i][1] == 'z') { tokenizer_path = argv[i + 1]; }
+        else if (argv[i][1] == 'm') { mode = argv[i + 1]; }
+        else if (argv[i][1] == 'y') { system_prompt = argv[i + 1]; }
+        else { error_usage(); }
+    }
+
+    // parameter validation/overrides
+    if (rng_seed <= 0) rng_seed = (unsigned int)time(NULL);
+    if (temperature < 0.0) temperature = 0.0;
+    if (topp < 0.0 || 1.0 < topp) topp = 0.9;
+    if (steps < 0) steps = 0;
+
+    // build the Transformer via the model .bin file
+    Transformer transformer;
+    build_transformer(&transformer, checkpoint_path);
+    if (steps == 0 || steps > transformer.config.seq_len) steps = transformer.config.seq_len; // override to ~max length
+
+    // build the Tokenizer via the tokenizer .bin file
+    Tokenizer tokenizer;
+    build_tokenizer(&tokenizer, tokenizer_path, transformer.config.vocab_size);
+
+    // build the Sampler
+    Sampler sampler;
+    build_sampler(&sampler, transformer.config.vocab_size, temperature, topp, rng_seed);
+
+    // run!
+    if (strcmp(mode, "generate") == 0) {
+        generate(&transformer, &tokenizer, &sampler, prompt, steps);
+    } else if (strcmp(mode, "chat") == 0) {
+        chat(&transformer, &tokenizer, &sampler, prompt, system_prompt, steps);
+    } else {
+        fprintf(stderr, "unknown mode: %s\n", mode);
+        error_usage();
+    }
+
+    // memory and file handles cleanup
+    free_sampler(&sampler);
+    free_tokenizer(&tokenizer);
+    free_transformer(&transformer);
+    return 0;
+}
+#endif

c/llama2/llgo.cfg

@@ -1,6 +0,0 @@
-{
-    "cl": [
-        "clang -emit-llvm -S -o llgo_autogen.ll -c llama2/run.c",
-        "rm llgo_autogen.lla; zip llgo_autogen.lla llgo_autogen.ll"
-    ]
-}

c/lua/_demo/coroutine/coroutine.go

@@ -0,0 +1,60 @@
+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)
+		c.Printf(c.Str("Resuming coroutine %d...\n"), status)
+		if status == lua.YIELD {
+			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)
+}

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/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,495 @@
+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          = int(-1)
+	NIL           = int(0)
+	BOOLEAN       = int(1)
+	LIGHTUSERDATA = int(2)
+	NUMBER        = int(3)
+	STRING        = int(4)
+	TABLE         = int(5)
+	FUNCTION      = int(6)
+	USERDATA      = int(7)
+	THREAD        = int(8)
+	UMTYPES       = 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 */
+// TODO(zzy): Context may not be c.Int
+type KContext c.Int
+
+// /*
+// ** Type for C functions registered with Lua
+// */
+
+// /*
+// ** 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);
+// State *(lua_newthread) (State *L);
+
+// 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)
+// */
+// LUA_API int             (lua_isinteger) (State *L, int idx);
+// llgo:link (*State).Isinteger C.lua_isinteger
+func (L *State) Isinteger(idx c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Isnumber C.lua_isnumber
+func (L *State) Isnumber(idx c.Int) c.Int { return 0 }
+
+// llgo:link (*State).Isstring C.lua_isstring
+func (L *State) Isstring(idx c.Int) c.Int { return 0 }
+
+// TODO(zzy):add to demo
+// llgo:link (*State).Type C.lua_type
+func (L *State) Type(idx c.Int) c.Int { return 0 }
+
+// TODO(zzy)
+// llgo:link (*State).Typename C.lua_typename
+func (L *State) Typename(tp c.Int) *c.Char { return nil }
+
+// 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 int             (lua_iscfunction) (State *L, int idx);
+// LUA_API int             (lua_isuserdata) (State *L, int idx);
+
+// LUA_API lua_Unsigned    (lua_rawlen) (State *L, int idx);
+// LUA_API lua_CFunction   (lua_tocfunction) (State *L, int idx);
+// 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).Pushstring C.lua_pushstring
+func (L *State) Pushstring(s *c.Char) *c.Char {
+	return nil
+}
+
+// llgo:link (*State).Pushlstring C.lua_pushlstring
+func (L *State) Pushlstring(s *c.Char, len c.Ulong) *c.Char {
+	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).Pushboolean C.lua_pushboolean
+func (L *State) Pushboolean(b c.Int) {}
+
+//const char *(lua_pushvfstring) (State *L, const char *fmt,va_list argp);
+//void  (lua_pushcclosure) (State *L, lua_CFunction fn, int n);
+//void  (lua_pushlightuserdata) (State *L, void *p);
+//int   (lua_pushthread) (State *L);
+
+// /*
+// ** 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 }
+
+// llgo:link (*State).Createtable C.lua_createtable
+func (L *State) Createtable(narr c.Int, nrec c.Int) {}
+
+// LUA_API int (lua_geti) (State *L, int idx, lua_Integer n);
+// LUA_API int (lua_rawget) (State *L, int idx);
+// LUA_API int (lua_rawgeti) (State *L, int idx, lua_Integer n);
+// LUA_API int (lua_rawgetp) (State *L, int idx, const void *p);
+
+// LUA_API void *(lua_newuserdatauv) (State *L, size_t sz, int nuvalue);
+// LUA_API int   (lua_getmetatable) (State *L, int objindex);
+// LUA_API int  (lua_getiuservalue) (State *L, int idx, int n);
+
+// /*
+// ** set functions (stack -> Lua)
+// */
+
+// TODO(zzy):add to demo
+// llgo:link (*State).Setglobal C.lua_setglobal
+func (L *State) Setglobal(name *c.Char) {}
+
+// 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);
+//int   (lua_setmetatable) (State *L, int objindex);
+//int   (lua_setiuservalue) (State *L, int idx, int n);
+
+// /*
+// ** 'load' and 'call' functions (load and run Lua code)
+// */
+
+// 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, KContext(c.Int(0)), nil)
+}
+
+// void  (lua_callk) (State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k);
+// #define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+// int   (lua_load) (State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode);
+
+// int (lua_dump) (State *L, lua_Writer writer, void *data, int strip);
+
+// /*
+// ** 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 }
+
+// TODO(zzy)
+// int  (lua_yieldk)     (State *L, int nresults, lua_KContext ctx, lua_KFunction k);
+// #define lua_yield(L,n)	lua_yieldk(L, (n), 0, NULL)
+
+// /*
+// ** 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
+// ** ===============================================================
+// */
+
+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) }
+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_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+// #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+// #define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+// #define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
+
+// #define lua_pushglobaltable(L)  ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
+
+// #define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
+
+// #define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
+
+// #define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
+
+// /* }============================================================== */
+
+// /*
+// ** {==============================================================
+// ** 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/math/math.go

@@ -26,6 +26,8 @@ const (
 	LLGoPackage = "decl"
 )
 
+// -----------------------------------------------------------------------------
+
 //go:linkname Acos C.acos
 func Acos(x float64) float64
 
@@ -177,3 +179,155 @@ func Tgamma(x float64) float64
 func Trunc(x float64) float64
 
 // -----------------------------------------------------------------------------
+
+//go:linkname Acosf C.acosf
+func Acosf(x float32) float32
+
+//go:linkname Acoshf C.acoshf
+func Acoshf(x float32) float32
+
+//go:linkname Asinf C.asinf
+func Asinf(x float32) float32
+
+//go:linkname Asinhf C.asinhf
+func Asinhf(x float32) float32
+
+//go:linkname Atanf C.atanf
+func Atanf(x float32) float32
+
+//go:linkname Atan2f C.atan2f
+func Atan2f(y, x float32) float32
+
+//go:linkname Atanhf C.atanhf
+func Atanhf(x float32) float32
+
+//go:linkname Cbrtf C.cbrtf
+func Cbrtf(x float32) float32
+
+//go:linkname Ceilf C.ceilf
+func Ceilf(x float32) float32
+
+//go:linkname Cosf C.cosf
+func Cosf(x float32) float32
+
+//go:linkname Coshf C.coshf
+func Coshf(x float32) float32
+
+//go:linkname Copysignf C.copysignf
+func Copysignf(x, y float32) float32
+
+//go:linkname Erff C.erff
+func Erff(x float32) float32
+
+//go:linkname Erfcf C.erfcf
+func Erfcf(x float32) float32
+
+//go:linkname Expf C.expf
+func Expf(x float32) float32
+
+//go:linkname Exp2f C.exp2f
+func Exp2f(x float32) float32
+
+//go:linkname Expm1f C.expm1f
+func Expm1f(x float32) float32
+
+//go:linkname Fdimf C.fdimf
+func Fdimf(x, y float32) float32
+
+//go:linkname Floorf C.floorf
+func Floorf(x float32) float32
+
+//go:linkname Fmaf C.fmaf
+func Fmaf(x, y, z float32) float32
+
+//go:linkname Fmaxf C.fmaxf
+func Fmaxf(x, y float32) float32
+
+//go:linkname Fminf C.fminf
+func Fminf(x, y float32) float32
+
+//go:linkname Fmodf C.fmodf
+func Fmodf(x, y float32) float32
+
+//go:linkname Frexpf C.frexpf
+func Frexpf(x float32, exp *c.Int) float32
+
+//go:linkname Gammaf C.gammaf
+func Gammaf(x float32) float32
+
+//go:linkname Hypotf C.hypotf
+func Hypotf(x, y float32) float32
+
+//go:linkname Ilogbf C.ilogbf
+func Ilogbf(x float32) c.Int
+
+//go:linkname J0f C.j0f
+func J0f(x float32) float32
+
+//go:linkname J1f C.j1f
+func J1f(x float32) float32
+
+//go:linkname Jnf C.jnf
+func Jnf(n c.Int, x float32) float32
+
+//go:linkname Ldexpf C.ldexpf
+func Ldexpf(x float32, exp c.Int) float32
+
+//go:linkname Lgammaf C.lgammaf
+func Lgammaf(x float32) float32
+
+//go:linkname Logf C.logf
+func Logf(x float32) float32
+
+//go:linkname Log10f C.log10f
+func Log10f(x float32) float32
+
+//go:linkname Log1pf C.log1pf
+func Log1pf(x float32) float32
+
+//go:linkname Log2f C.log2f
+func Log2f(x float32) float32
+
+//go:linkname Logbf C.logbf
+func Logbf(x float32) float32
+
+//go:linkname Modff C.modff
+func Modff(x float32, ipart *float32) float32
+
+//go:linkname Nanf C.nanf
+func Nanf(tag *c.Char) float32
+
+//go:linkname Nextafterf C.nextafterf
+func Nextafterf(x, y float32) float32
+
+//go:linkname Powf C.powf
+func Powf(x, y float32) float32
+
+//go:linkname Remainderf C.remainderf
+func Remainderf(x, y float32) float32
+
+//go:linkname Roundf C.roundf
+func Roundf(x float32) float32
+
+//go:linkname Sinf C.sinf
+func Sinf(x float32) float32
+
+//go:linkname Sinhf C.sinhf
+func Sinhf(x float32) float32
+
+//go:linkname Sqrtf C.sqrtf
+func Sqrtf(x float32) float32
+
+//go:linkname Tanf C.tanf
+func Tanf(x float32) float32
+
+//go:linkname Tanhf C.tanhf
+func Tanhf(x float32) float32
+
+//go:linkname Tgammaf C.tgammaf
+func Tgammaf(x float32) float32
+
+//go:linkname Truncf C.truncf
+func Truncf(x float32) float32
+
+// -----------------------------------------------------------------------------

c/math/rand/rand.go

@@ -14,39 +14,41 @@
  * limitations under the License.
  */
 
-package fs
+package rand
 
-// llgo:skipall
 import (
 	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "decl"
 )
 
 // -----------------------------------------------------------------------------
 
-// A FileMode represents a file's mode and permission bits.
-// The bits have the same definition on all systems, so that
-// information about files can be moved from one system
-// to another portably. Not all bits apply to all systems.
-// The only required bit is [ModeDir] for directories.
-type FileMode uint32
+//go:linkname Rand C.rand
+func Rand() c.Int
+
+//go:linkname RandR C.rand_r
+func RandR(*c.Uint) c.Int
+
+//go:linkname Srand C.srand
+func Srand(c.Uint)
+
+//go:linkname Sranddev C.sranddev
+func Sranddev()
 
 // -----------------------------------------------------------------------------
 
-// PathError records an error and the operation and file path that caused it.
-type PathError struct {
-	Op   string
-	Path string
-	Err  error
-}
+//go:linkname Random C.random
+func Random() c.Long
 
-func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }
+//go:linkname Srandom C.srandom
+func Srandom(c.Uint)
 
-func (e *PathError) Unwrap() error { return e.Err }
-
-// Timeout reports whether this error represents a timeout.
-func (e *PathError) Timeout() bool {
-	t, ok := e.Err.(interface{ Timeout() bool })
-	return ok && t.Timeout()
-}
+//go:linkname Srandomdev C.srandomdev
+func Srandomdev()
 
 // -----------------------------------------------------------------------------

c/neco/_demo/cgen/_c/gen.c

@@ -0,0 +1,34 @@
+#include "../../../_wrap/neco.h"
+#include <stdio.h>
+#include <unistd.h>
+
+void coroutine(int argc, void *argv[]) {
+  // Yield each int to the caller, one at a time.
+  for (int i = 0; i < 10; i++) {
+    neco_gen_yield(&i);
+  }
+}
+
+static int __neco_main() {
+
+  // Create a new generator coroutine that is used to send ints.
+  neco_gen *gen;
+  neco_gen_start(&gen, sizeof(int), coroutine, 0);
+
+  // Iterate over each int until the generator is closed.
+  int i;
+  while (neco_gen_next(gen, &i) != NECO_CLOSED) {
+    printf("%d\n", i);
+  }
+
+  // This coroutine no longer needs the generator.
+  neco_gen_release(gen);
+  return 0;
+}
+static void _neco_main() { __neco_exit_prog(__neco_main()); }
+void run_main() {
+  neco_env_setpaniconerror(true);
+  neco_env_setcanceltype(NECO_CANCEL_ASYNC);
+  int ret = neco_start(_neco_main, 0);
+  fprintf(stderr, "neco_start: %s (code %d)\n", neco_strerror(ret), ret);
+};

c/neco/_demo/cgen/cgen.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	_ "unsafe"
+
+	_ "github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoFiles   = "_c/gen.c; ../../_wrap/neco.c"
+	LLGoPackage = "link"
+)
+
+func main() {
+	runMain()
+}
+
+//go:linkname runMain C.run_main
+func runMain()

c/neco/_demo/gen/gen.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/neco"
+)
+
+func coroutine(argc c.Int, argv *c.Pointer) {
+	// Yield each int to the caller, one at a time.
+	for i := 0; i < 10; i++ {
+		neco.GenYield(unsafe.Pointer(&i))
+	}
+}
+
+func necoMain(argc c.Int, argv *c.Pointer) {
+	// Create a new generator coroutine that is used to send ints.
+	var gen *neco.Gen
+	neco.GenStart(&gen, unsafe.Sizeof(0), coroutine, 0)
+
+	// Iterate over each int until the generator is closed.
+	var i int
+	for neco.GenNext(gen, unsafe.Pointer(&i)) != neco.CLOSED {
+		c.Printf(c.Str("%d\n"), i)
+	}
+
+	neco.GenRelease(gen)
+	neco.ExitProg(0)
+}
+
+func main() {
+	neco.EnvSetpaniconerror(true)
+	neco.EnvSetcanceltype(neco.CANCEL_ASYNC)
+	var ret = neco.Start(necoMain, 0)
+	c.Fprintf(c.Stderr, c.Str("neco_start: %s (code %d)\n"), neco.Strerror(ret), ret)
+}

c/neco/_wrap/neco.h

@@ -0,0 +1,453 @@
+// https://github.com/tidwall/neco
+//
+// Copyright 2024 Joshua J Baker. All rights reserved.
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+//
+// Neco -- Coroutine library for C
+
+#ifndef NECO_H
+#define NECO_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/types.h>
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#else
+#include <netdb.h>
+#include <sys/socket.h>
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// basic operations
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup BasicOperations Basic operations
+/// Neco provides standard operations for starting a coroutine, sleeping, 
+/// suspending, resuming, yielding to another coroutine, joining/waiting for
+/// child coroutines, and exiting a running coroutine.
+/// @{
+int neco_start(void(*coroutine)(int argc, void *argv[]), int argc, ...);
+int neco_startv(void(*coroutine)(int argc, void *argv[]), int argc, void *argv[]);
+int neco_yield(void);
+int neco_sleep(int64_t nanosecs);
+int neco_sleep_dl(int64_t deadline);
+int neco_join(int64_t id);
+int neco_join_dl(int64_t id, int64_t deadline);
+int neco_suspend(void);
+int neco_suspend_dl(int64_t deadline);
+int neco_resume(int64_t id);
+void neco_exit(void);
+int64_t neco_getid(void);
+int64_t neco_lastid(void);
+int64_t neco_starterid(void);
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// channels
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Channels Channels
+/// Channels allow for sending and receiving values between coroutines.
+/// By default, sends and receives will block until the other side is ready.
+/// This allows the coroutines to synchronize without using locks or condition
+/// variables.
+/// @{
+typedef struct neco_chan neco_chan;
+
+int neco_chan_make(neco_chan **chan, size_t data_size, size_t capacity);
+int neco_chan_retain(neco_chan *chan);
+int neco_chan_release(neco_chan *chan);
+int neco_chan_send(neco_chan *chan, void *data);
+int neco_chan_send_dl(neco_chan *chan, void *data, int64_t deadline);
+int neco_chan_broadcast(neco_chan *chan, void *data);
+int neco_chan_recv(neco_chan *chan, void *data);
+int neco_chan_recv_dl(neco_chan *chan, void *data, int64_t deadline);
+int neco_chan_tryrecv(neco_chan *chan, void *data);
+int neco_chan_close(neco_chan *chan);
+int neco_chan_select(int nchans, ...);
+int neco_chan_select_dl(int64_t deadline, int nchans, ...);
+int neco_chan_selectv(int nchans, neco_chan *chans[]);
+int neco_chan_selectv_dl(int nchans, neco_chan *chans[], int64_t deadline);
+int neco_chan_tryselect(int nchans, ...);
+int neco_chan_tryselectv(int nchans, neco_chan *chans[]);
+int neco_chan_case(neco_chan *chan, void *data);
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// generators
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Generators Generators
+/// A generator is a specialized iterator-bound coroutine that can produce a
+/// sequence of values to be iterated over.
+/// @{
+typedef struct neco_gen neco_gen;
+
+int neco_gen_start(neco_gen **gen, size_t data_size, void(*coroutine)(int argc, void *argv[]), int argc, ...);
+int neco_gen_startv(neco_gen **gen, size_t data_size, void(*coroutine)(int argc, void *argv[]), int argc, void *argv[]);
+int neco_gen_retain(neco_gen *gen);
+int neco_gen_release(neco_gen *gen);
+int neco_gen_yield(void *data);
+int neco_gen_yield_dl(void *data, int64_t deadline);
+int neco_gen_next(neco_gen *gen, void *data);
+int neco_gen_next_dl(neco_gen *gen, void *data, int64_t deadline);
+int neco_gen_close(neco_gen *gen);
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// synchronization mechanisms
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Mutexes Mutexes
+/// A mutex is synchronization mechanism that blocks access to variables by
+/// multiple coroutines at once. This enforces exclusive access by a coroutine
+/// to a variable or set of variables and helps to avoid data inconsistencies
+/// due to race conditions.
+/// @{
+typedef struct { _Alignas(16) char _[48]; } neco_mutex;
+
+#define NECO_MUTEX_INITIALIZER { 0 }
+
+int neco_mutex_init(neco_mutex *mutex);
+int neco_mutex_lock(neco_mutex *mutex);
+int neco_mutex_lock_dl(neco_mutex *mutex, int64_t deadline);
+int neco_mutex_trylock(neco_mutex *mutex);
+int neco_mutex_unlock(neco_mutex *mutex);
+int neco_mutex_rdlock(neco_mutex *mutex);
+int neco_mutex_rdlock_dl(neco_mutex *mutex, int64_t deadline);
+int neco_mutex_tryrdlock(neco_mutex *mutex);
+/// @}
+
+/// @defgroup WaitGroups WaitGroups
+/// A WaitGroup waits for a multiple coroutines to finish. 
+/// The main coroutine calls neco_waitgroup_add() to set the number of
+/// coroutines to wait for. Then each of the coroutines runs and calls
+/// neco_waitgroup_done() when complete.
+/// At the same time, neco_waitgroup_wait() can be used to block until all
+/// coroutines are completed.
+/// @{
+typedef struct { _Alignas(16) char _[48]; } neco_waitgroup;
+
+#define NECO_WAITGROUP_INITIALIZER { 0 }
+
+int neco_waitgroup_init(neco_waitgroup *waitgroup);
+int neco_waitgroup_add(neco_waitgroup *waitgroup, int delta);
+int neco_waitgroup_done(neco_waitgroup *waitgroup);
+int neco_waitgroup_wait(neco_waitgroup *waitgroup);
+int neco_waitgroup_wait_dl(neco_waitgroup *waitgroup, int64_t deadline);
+/// @}
+
+/// @defgroup CondVar Condition variables
+/// A condition variable is a synchronization mechanism that allows coroutines
+/// to suspend execution until some condition is true. 
+/// @{
+typedef struct { _Alignas(16) char _[48]; } neco_cond;
+#define NECO_COND_INITIALIZER { 0 }
+
+int neco_cond_init(neco_cond *cond);
+int neco_cond_signal(neco_cond *cond);
+int neco_cond_broadcast(neco_cond *cond);
+int neco_cond_wait(neco_cond *cond, neco_mutex *mutex);
+int neco_cond_wait_dl(neco_cond *cond, neco_mutex *mutex, int64_t deadline);
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// file descriptors
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Posix Posix wrappers
+/// Functions that work like their Posix counterpart but do not block, allowing
+/// for usage in a Neco coroutine.
+/// @{
+
+// wrappers for various posix operations.
+ssize_t neco_read(int fd, void *data, size_t nbytes);
+ssize_t neco_read_dl(int fd, void *data, size_t nbytes, int64_t deadline);
+ssize_t neco_write(int fd, const void *data, size_t nbytes);
+ssize_t neco_write_dl(int fd, const void *data, size_t nbytes, int64_t deadline);
+int neco_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+int neco_accept_dl(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int64_t deadline);
+int neco_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int neco_connect_dl(int sockfd, const struct sockaddr *addr, socklen_t addrlen, int64_t deadline);
+int neco_getaddrinfo(const char *node, const char *service,
+    const struct addrinfo *hints, struct addrinfo **res);
+int neco_getaddrinfo_dl(const char *node, const char *service,
+    const struct addrinfo *hints, struct addrinfo **res, int64_t deadline);
+/// @}
+
+/// @defgroup Posix2 File descriptor helpers
+/// Functions for working with file descriptors.
+/// @{
+
+// utility for enabling non-blocking on existing file descriptors
+int neco_setnonblock(int fd, bool nonblock, bool *oldnonblock);
+
+// wait for a file descriptor to be readable or writeable.
+#define NECO_WAIT_READ  1
+#define NECO_WAIT_WRITE 2
+
+int neco_wait(int fd, int mode);
+int neco_wait_dl(int fd, int mode, int64_t deadline);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// networking
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Networking Networking utilities
+/// @{
+
+int neco_serve(const char *network, const char *address);
+int neco_serve_dl(const char *network, const char *address, int64_t deadline);
+int neco_dial(const char *network, const char *address);
+int neco_dial_dl(const char *network, const char *address, int64_t deadline);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// cancelation
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Cancelation Cancelation
+/// @{
+
+int neco_cancel(int64_t id);
+int neco_cancel_dl(int64_t id, int64_t deadline);
+
+#define NECO_CANCEL_ASYNC      1
+#define NECO_CANCEL_INLINE     2
+#define NECO_CANCEL_ENABLE     3
+#define NECO_CANCEL_DISABLE    4
+
+int neco_setcanceltype(int type, int *oldtype);
+int neco_setcancelstate(int state, int *oldstate);
+
+#define neco_cleanup_push(routine, arg) {__neco_c0(&(char[32]){0},routine,arg);
+#define neco_cleanup_pop(execute)        __neco_c1(execute);}
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// random number generator
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Random Random number generator
+/// @{
+
+#define NECO_CSPRNG 0 // Cryptographically secure pseudorandom number generator
+#define NECO_PRNG   1 // Pseudorandom number generator (non-crypto, faster)
+
+int neco_rand_setseed(int64_t seed, int64_t *oldseed);
+int neco_rand(void *data, size_t nbytes, int attr);
+int neco_rand_dl(void *data, size_t nbytes, int attr, int64_t deadline);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// signal handling
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Signals Signals
+/// Allows for signals, such as SIGINT (Ctrl-C), to be intercepted or ignored.
+/// @{
+
+int neco_signal_watch(int signo);
+int neco_signal_wait(void);
+int neco_signal_wait_dl(int64_t deadline);
+int neco_signal_unwatch(int signo);
+
+/// @}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// background worker
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Worker Background worker
+/// Run arbitrary code in a background worker thread
+/// @{
+
+int neco_work(int64_t pin, void(*work)(void *udata), void *udata);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// Stats and information
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Stats Stats and information
+/// @{
+
+typedef struct neco_stats {
+    size_t coroutines;   ///< Number of active coroutines
+    size_t sleepers;     ///< Number of sleeping coroutines
+    size_t evwaiters;    ///< Number of coroutines waiting on I/O events
+    size_t sigwaiters;   ///<
+    size_t senders;      ///<
+    size_t receivers;    ///<
+    size_t locked;       ///<
+    size_t waitgroupers; ///<
+    size_t condwaiters;  ///<
+    size_t suspended;    ///<
+    size_t workers;      ///< Number of background worker threads
+} neco_stats;
+
+int neco_getstats(neco_stats *stats);
+int neco_is_main_thread(void);
+const char *neco_switch_method(void);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// global behaviors
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup GlobalFuncs Global environment
+/// @{
+
+void neco_env_setallocator(void *(*malloc)(size_t), void *(*realloc)(void*, size_t), void (*free)(void*));
+void neco_env_setpaniconerror(bool paniconerror);
+void neco_env_setcanceltype(int type);
+void neco_env_setcancelstate(int state);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// time and duration
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Time Time
+/// Functions for working with time.
+///
+/// The following defines are available for convenience.
+///
+/// ```c
+/// #define NECO_NANOSECOND  INT64_C(1)
+/// #define NECO_MICROSECOND INT64_C(1000)
+/// #define NECO_MILLISECOND INT64_C(1000000)
+/// #define NECO_SECOND      INT64_C(1000000000)
+/// #define NECO_MINUTE      INT64_C(60000000000)
+/// #define NECO_HOUR        INT64_C(3600000000000)
+/// ```
+///
+/// @{
+
+#define NECO_NANOSECOND  INT64_C(1)
+#define NECO_MICROSECOND INT64_C(1000)
+#define NECO_MILLISECOND INT64_C(1000000)
+#define NECO_SECOND      INT64_C(1000000000)
+#define NECO_MINUTE      INT64_C(60000000000)
+#define NECO_HOUR        INT64_C(3600000000000)
+
+int64_t neco_now(void);
+
+///@}
+
+////////////////////////////////////////////////////////////////////////////////
+// errors
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup ErrorFuncs Error handling
+/// Functions for working with [Neco errors](./API.md#neco-errors). 
+/// @{
+
+#define NECO_OK              0  ///< Successful result (no error)
+#define NECO_ERROR          -1  ///< System error (check errno)
+#define NECO_INVAL          -2  ///< Invalid argument
+#define NECO_PERM           -3  ///< Operation not permitted
+#define NECO_NOMEM          -4  ///< Cannot allocate memory
+#define NECO_EOF            -5  ///< End of file or stream (neco_stream_*)
+#define NECO_NOTFOUND       -6  ///< No such coroutine (neco_cancel)
+#define NECO_NOSIGWATCH     -7  ///< Not watching on a signal
+#define NECO_CLOSED         -8  ///< Channel is closed
+#define NECO_EMPTY          -9  ///< Channel is empty (neco_chan_tryrecv)
+#define NECO_TIMEDOUT      -10  ///< Deadline has elapsed (neco_*_dl)
+#define NECO_CANCELED      -11  ///< Operation canceled (by neco_cancel)
+#define NECO_BUSY          -12  ///< Resource busy (mutex_trylock)
+#define NECO_NEGWAITGRP    -13  ///< Negative waitgroup counter
+#define NECO_GAIERROR      -14  ///< Error with getaddrinfo (check neco_gai_error)
+#define NECO_UNREADFAIL    -15  ///< Failed to unread byte (neco_stream_unread_byte)
+#define NECO_PARTIALWRITE  -16  ///< Failed to write all data (neco_stream_flush)
+#define NECO_NOTGENERATOR  -17  ///< Coroutine is not a generator (neco_gen_yield)
+#define NECO_NOTSUSPENDED  -18  ///< Coroutine is not suspended (neco_resume)
+
+const char *neco_strerror(ssize_t errcode);
+int neco_lasterr(void);
+int neco_gai_lasterr(void);
+int neco_panic(const char *fmt, ...);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// streama
+////////////////////////////////////////////////////////////////////////////////
+
+/// @defgroup Streams Streams and Buffered I/O
+/// Create a Neco stream from a file descriptor using neco_stream_make() or
+/// a buffered stream using neco_stream_make_buffered().
+/// @{
+
+typedef struct neco_stream neco_stream;
+
+int neco_stream_make(neco_stream **stream, int fd);
+int neco_stream_make_buffered(neco_stream **stream, int fd);
+int neco_stream_close(neco_stream *stream);
+int neco_stream_close_dl(neco_stream *stream, int64_t deadline);
+ssize_t neco_stream_read(neco_stream *stream, void *data, size_t nbytes);
+ssize_t neco_stream_read_dl(neco_stream *stream, void *data, size_t nbytes, int64_t deadline);
+ssize_t neco_stream_write(neco_stream *stream, const void *data, size_t nbytes);
+ssize_t neco_stream_write_dl(neco_stream *stream, const void *data, size_t nbytes, int64_t deadline);
+ssize_t neco_stream_readfull(neco_stream *stream, void *data, size_t nbytes);
+ssize_t neco_stream_readfull_dl(neco_stream *stream, void *data, size_t nbytes, int64_t deadline);
+int neco_stream_read_byte(neco_stream *stream);
+int neco_stream_read_byte_dl(neco_stream *stream, int64_t deadline);
+int neco_stream_unread_byte(neco_stream *stream);
+int neco_stream_flush(neco_stream *stream);
+int neco_stream_flush_dl(neco_stream *stream, int64_t deadline);
+ssize_t neco_stream_buffered_read_size(neco_stream *stream);
+ssize_t neco_stream_buffered_write_size(neco_stream *stream);
+
+/// @}
+
+////////////////////////////////////////////////////////////////////////////////
+// happy convenience macro
+////////////////////////////////////////////////////////////////////////////////
+
+// int neco_main(int argc, char *argv[]);
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define neco_main \
+__neco_main(int argc, char *argv[]); \
+static void _neco_main(int argc, void *argv[]) { \
+    (void)argc; \
+    __neco_exit_prog(__neco_main(*(int*)argv[0], *(char***)argv[1])); \
+} \
+int main(int argc, char *argv[]) { \
+    neco_env_setpaniconerror(true); \
+    neco_env_setcanceltype(NECO_CANCEL_ASYNC); \
+    int ret = neco_start(_neco_main, 2, &argc, &argv); \
+    fprintf(stderr, "neco_start: %s (code %d)\n", neco_strerror(ret), ret); \
+    return -1; \
+}; \
+int __neco_main
+
+////////////////////////////////////////////////////////////////////////////////
+// private functions, not to be call directly
+////////////////////////////////////////////////////////////////////////////////
+
+void __neco_c0(void*,void(*)(void*),void*); 
+void __neco_c1(int);
+void __neco_exit_prog(int);
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef EAI_SYSTEM
+#define EAI_SYSTEM 11
+#endif
+
+#endif // NECO_H

c/neco/neco.go

@@ -0,0 +1,81 @@
+package neco
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoFiles   = "_wrap/neco.c"
+	LLGoPackage = "link"
+)
+
+const (
+	OK           = 0   ///< Successful result (no error)
+	ERROR        = -1  ///< System error (check errno)
+	INVAL        = -2  ///< Invalid argument
+	PERM         = -3  ///< Operation not permitted
+	NOMEM        = -4  ///< Cannot allocate memory
+	EOF          = -5  ///< End of file or stream (neco_stream_*)
+	NOTFOUND     = -6  ///< No such coroutine (neco_cancel)
+	NOSIGWATCH   = -7  ///< Not watching on a signal
+	CLOSED       = -8  ///< Channel is closed
+	EMPTY        = -9  ///< Channel is empty (neco_chan_tryrecv)
+	TIMEDOUT     = -10 ///< Deadline has elapsed (neco_*_dl)
+	CANCELED     = -11 ///< Operation canceled (by neco_cancel)
+	BUSY         = -12 ///< Resource busy (mutex_trylock)
+	NEGWAITGRP   = -13 ///< Negative waitgroup counter
+	GAIERROR     = -14 ///< Error with getaddrinfo (check neco_gai_error)
+	UNREADFAIL   = -15 ///< Failed to unread byte (neco_stream_unread_byte)
+	PARTIALWRITE = -16 ///< Failed to write all data (neco_stream_flush)
+	NOTGENERATOR = -17 ///< Coroutine is not a generator (neco_gen_yield)
+	NOTSUSPENDED = -18 ///< Coroutine is not suspended (neco_resume)
+
+	CANCEL_ASYNC   = 1
+	CANCEL_INLINE  = 2
+	CANCEL_ENABLE  = 3
+	CANCEL_DISABLE = 4
+
+	EAI_SYSTEM = 11
+
+	NANOSECOND  = int64(1)
+	MICROSECOND = int64(1000)
+	MILLISECOND = int64(1000000)
+	SECOND      = int64(1000000000)
+	MINUTE      = int64(60000000000)
+	HOUR        = int64(3600000000000)
+)
+
+// generator
+type Gen struct{}
+
+// llgo:type C
+type Coro = func(argc c.Int, argv *c.Pointer)
+
+//go:linkname GenYield C.neco_gen_yield
+func GenYield(data c.Pointer) c.Int
+
+//go:linkname GenNext C.neco_gen_next
+func GenNext(gen *Gen, data c.Pointer) c.Int
+
+//go:linkname GenStart C.neco_gen_start
+func GenStart(gen **Gen, dataSize uintptr, co Coro, argc c.Int, __llgo_va_list ...any) c.Int
+
+//go:linkname GenRelease C.neco_gen_release
+func GenRelease(gen *Gen) c.Int
+
+//go:linkname ExitProg C.__neco_exit_prog
+func ExitProg(code c.Int)
+
+//go:linkname EnvSetpaniconerror C.neco_env_setpaniconerror
+func EnvSetpaniconerror(paniconerror bool)
+
+//go:linkname EnvSetcanceltype C.neco_env_setcanceltype
+func EnvSetcanceltype(type_ c.Int)
+
+//go:linkname Strerror C.neco_strerror
+func Strerror(errcode c.Int) *c.Char
+
+//go:linkname Start C.neco_start
+func Start(co Coro, argc c.Int, __llgo_va_list ...any) c.Int

c/os/os.go

@@ -24,6 +24,7 @@ import (
 	_ "unsafe"
 
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/syscall"
 )
 
 const (
@@ -34,13 +35,39 @@ const (
 	PATH_MAX = C.PATH_MAX
 )
 
+const (
+	/* get file status flags */
+	F_GETFL = 3
+	/* set file status flags */
+	F_SETFL = 4
+
+	/* open for reading only */
+	O_RDONLY = 0x0000
+	/* open for writing only */
+	O_WRONLY = 0x0001
+	/* open for reading and writing */
+	O_RDWR = 0x0002
+	/* mask for above modes */
+	O_ACCMODE = 0x0003
+
+	/* no delay */
+	O_NONBLOCK = 0x00000004
+	/* create if nonexistant */
+	O_CREAT = 0x00000200
+	/* truncate to zero length */
+	O_TRUNC = 0x00000400
+)
+
 type (
 	ModeT C.mode_t
 	UidT  C.uid_t
 	GidT  C.gid_t
 	OffT  C.off_t
 	DevT  C.dev_t
-	StatT C.struct_stat
+)
+
+type (
+	StatT = syscall.Stat_t
 )
 
 //go:linkname Errno errno
@@ -104,8 +131,8 @@ func Chroot(path *c.Char) c.Int
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Environ C.environ
-func Environ() **c.Char
+//go:linkname Environ environ
+var Environ **c.Char
 
 //go:linkname Getenv C.getenv
 func Getenv(name *c.Char) *c.Char
@@ -142,11 +169,17 @@ func Fstatat(dirfd c.Int, path *c.Char, buf *StatT, flags c.Int) c.Int
 // -----------------------------------------------------------------------------
 
 //go:linkname Open C.open
-func Open(path *c.Char, flags c.Int, mode ModeT) c.Int
+func Open(path *c.Char, flags c.Int, __llgo_va_list ...any) c.Int
+
+//go:linkname Openat C.openat
+func Openat(dirfd c.Int, path *c.Char, flags c.Int, mode ModeT) c.Int
 
 //go:linkname Creat C.creat
 func Creat(path *c.Char, mode ModeT) c.Int
 
+//go:linkname Fcntl C.fcntl
+func Fcntl(a c.Int, b c.Int, __llgo_va_list ...any) c.Int
+
 //go:linkname Dup C.dup
 func Dup(fd c.Int) c.Int
 
@@ -201,14 +234,78 @@ func Isatty(fd c.Int) c.Int
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Exit C.exit
-func Exit(c.Int)
+// Execl(const char *path, const char *arg0, ..., /*, (char *)0, */)
+//
+// Execl requires the full path of the program to be provided.
+//
+//go:linkname Execl C.execl
+func Execl(path *c.Char, __llgo_va_list ...any) c.Int
+
+// Execle(const char *path, const char *arg0, ..., /* (char *)0, char *const envp[] */)
+//
+//go:linkname Execle C.execle
+func Execle(path *c.Char, __llgo_va_list ...any) c.Int
+
+// Execlp(const char *file, const char *arg0, ..., /*, (char *)0, */)
+//
+// Execlp only needs to provide the program name and it will search for the program in the
+// paths specified in the PATH environment variable.
+//
+//go:linkname Execlp C.execlp
+func Execlp(file *c.Char, __llgo_va_list ...any) c.Int
+
+//go:linkname Execv C.execv
+func Execv(path *c.Char, argv **c.Char) c.Int
+
+//go:linkname Execve C.execve
+func Execve(path *c.Char, argv **c.Char, envp **c.Char) c.Int
+
+//go:linkname Execvp C.execvp
+func Execvp(file *c.Char, argv **c.Char) c.Int
+
+// -----------------------------------------------------------------------------
+
+type PidT c.Int
+
+//go:linkname Fork C.fork
+func Fork() PidT
 
 //go:linkname Getpid C.getpid
-func Getpid() c.Int
+func Getpid() PidT
 
 //go:linkname Getppid C.getppid
-func Getppid() c.Int
+func Getppid() PidT
+
+//go:linkname Kill C.kill
+func Kill(pid PidT, sig c.Int) c.Int
+
+// If wait() returns due to a stopped or terminated child process, the process ID
+// of the child is returned to the calling process.  Otherwise, a value of -1 is
+// returned and errno is set to indicate the error.
+//
+//go:linkname Wait C.wait
+func Wait(statLoc *c.Int) PidT
+
+// If wait3(), wait4(), or waitpid() returns due to a stopped or terminated child
+// process, the process ID of the child is returned to the calling process.  If
+// there are no children not previously awaited, -1 is returned with errno set to
+// [ECHILD].  Otherwise, if WNOHANG is specified and there are no stopped or exited
+// children, 0 is returned.  If an error is detected or a caught signal aborts the
+// call, a value of -1 is returned and errno is set to indicate the error.
+//
+//go:linkname Wait3 C.wait3
+func Wait3(statLoc *c.Int, options c.Int, rusage *syscall.Rusage) PidT
+
+//go:linkname Wait4 C.wait4
+func Wait4(pid PidT, statLoc *c.Int, options c.Int, rusage *syscall.Rusage) PidT
+
+//go:linkname Waitpid C.waitpid
+func Waitpid(pid PidT, statLoc *c.Int, options c.Int) PidT
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Exit C.exit
+func Exit(c.Int)
 
 //go:linkname Getuid C.getuid
 func Getuid() UidT
@@ -223,3 +320,43 @@ func Getgid() GidT
 func Getegid() GidT
 
 // -----------------------------------------------------------------------------
+
+//go:linkname Getrlimit C.getrlimit
+func Getrlimit(resource c.Int, rlp *syscall.Rlimit) c.Int
+
+//go:linkname Setrlimit C.setrlimit
+func Setrlimit(resource c.Int, rlp *syscall.Rlimit) c.Int
+
+// -----------------------------------------------------------------------------
+
+// Upon successful completion, the value 0 is returned; otherwise the value -1
+// is returned and the global variable errno is set to indicate the error.
+//
+//go:linkname Sysctl C.sysctl
+func Sysctl(
+	name *c.Int, namelen c.Uint,
+	oldp c.Pointer, oldlenp *uintptr,
+	newp c.Pointer, newlen uintptr) c.Int
+
+//go:linkname Sysctlbyname C.sysctlbyname
+func Sysctlbyname(
+	name *c.Char, oldp c.Pointer, oldlenp *uintptr,
+	newp c.Pointer, newlen uintptr) c.Int
+
+// The sysctlnametomib() function accepts an ASCII representation  of  the
+// name,  looks up the integer name	vector,	and returns the	numeric	repre-
+// sentation in the	mib array pointed to by	mibp.  The number of  elements
+// in the mib array	is given by the	location specified by sizep before the
+// call, and that location gives the number	of entries copied after	a suc-
+// cessful	call.	The  resulting	mib and	size may be used in subsequent
+// sysctl()	calls to get the data  associated  with	 the  requested	 ASCII
+// name.   This interface is intended for use by applications that want to
+// repeatedly request the same variable (the  sysctl()  function  runs  in
+// about  a	third the time as the same request made	via the	sysctlbyname()
+// function).  The sysctlnametomib() function is also useful for  fetching
+// mib  prefixes and then adding a final component.
+//
+//go:linkname Sysctlnametomib C.sysctlnametomib
+func Sysctlnametomib(name *c.Char, mibp *c.Int, sizep *uintptr) c.Int
+
+// -----------------------------------------------------------------------------

c/pthread/sync/_sema.go

@@ -0,0 +1,70 @@
+/*
+ * 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 sync
+
+// #include <semaphore.h>
+import "C"
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// Sem represents a semaphore.
+type Sem C.sem_t
+
+// initializes the unnamed semaphore at the address
+// pointed to by sem.  The value argument specifies the initial
+// value for the semaphore.
+//
+// The pshared argument indicates whether this semaphore is to be
+// shared between the threads of a process, or between processes.
+//
+// If pshared has the value 0, then the semaphore is shared between
+// the threads of a process, and should be located at some address
+// that is visible to all threads (e.g., a global variable, or a
+// variable allocated dynamically on the heap).
+//
+// If pshared is nonzero, then the semaphore is shared between
+// processes, and should be located in a region of shared memory
+// (see shm_open(3), mmap(2), and shmget(2)).  (Since a child
+// created by fork(2) inherits its parent's memory mappings, it can
+// also access the semaphore.)  Any process that can access the
+// shared memory region can operate on the semaphore using
+// sem_post(3), sem_wait(3), and so on.
+//
+// Initializing a semaphore that has already been initialized
+// results in undefined behavior.
+//
+// llgo:link (*Sem).Init C.sem_init
+func (*Sem) Init(pshared c.Int, value c.Uint) c.Int { return 0 }
+
+// llgo:link (*Sem).Destroy C.sem_destroy
+func (*Sem) Destroy() c.Int { return 0 }
+
+// llgo:link (*Sem).Post C.sem_post
+func (*Sem) Post() c.Int { return 0 }
+
+// llgo:link (*Sem).Wait C.sem_wait
+func (*Sem) Wait() c.Int { return 0 }
+
+// llgo:link (*Sem).TryWait C.sem_trywait
+func (*Sem) TryWait() c.Int { return 0 }
+
+// llgo:link (*Sem).GetValue C.sem_getvalue
+func (*Sem) GetValue(sval *c.Int) c.Int { return 0 }

c/pthread/sync/sync.go

@@ -143,10 +143,10 @@ func (a *CondAttr) Init(attr *CondAttr) c.Int { return 0 }
 func (a *CondAttr) Destroy() {}
 
 // llgo:link (*CondAttr).SetClock C.pthread_condattr_setclock
-func (a *CondAttr) SetClock(clock time.ClockID) c.Int { return 0 }
+func (a *CondAttr) SetClock(clock time.ClockidT) c.Int { return 0 }
 
 // llgo:link (*CondAttr).GetClock C.pthread_condattr_getclock
-func (a *CondAttr) GetClock(clock *time.ClockID) c.Int { return 0 }
+func (a *CondAttr) GetClock(clock *time.ClockidT) c.Int { return 0 }
 
 // -----------------------------------------------------------------------------
 

c/raylib/README.md

@@ -0,0 +1,30 @@
+# LLGo wrapper of raysan5/raylib
+
+## How to install
+
+### on macOS (Homebrew)
+
+```sh
+brew install raylib
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+TODO
+```
+
+## Demos
+
+The `_demo` directory contains our demos (it start with `_` to prevent the `go` command from compiling it):
+
+- [tetris](_demo/tetris/tetris.go): tetris powered by raylib
+
+### How to run demos
+
+To run the demos in directory `_demo`:
+
+```sh
+cd <demo-directory>  # eg. cd _demo/tetris
+llgo run .
+```

c/raylib/_demo/raylibdemo/raydemo.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/raylib"
+)
+
+func main() {
+	const screenWidth = 800
+	const screenHeight = 450
+	raylib.InitWindow(screenWidth, screenHeight, c.Str("Raylib DEMO"))
+	for !raylib.WindowShouldClose() {
+		raylib.BeginDrawing()
+		raylib.ClearBackground(raylib.RAYWHITE)
+		raylib.DrawRectangle(screenWidth/2-50, screenHeight/2-50, 100, 100, raylib.BLUE)
+		raylib.EndDrawing()
+	}
+}

c/raylib/_demo/tetris/tetris.go

@@ -0,0 +1,181 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/raylib"
+)
+
+const (
+	BOARD_WIDTH  = 10
+	BOARD_HEIGHT = 20
+	BLOCK_SIZE   = 30
+
+	SCREENWIDTH  = 300
+	SCREENHEIGHT = 600
+)
+
+const MAX_BLOCKS = 4
+
+type Shape struct {
+	Blocks [MAX_BLOCKS]raylib.Vector2
+	Color  raylib.Color
+}
+
+var SHAPES = []Shape{
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 0, Y: 0}, {X: 1, Y: 0}, {X: 2, Y: 0}, {X: 3, Y: 0}}, Color: raylib.SKYBLUE},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 0, Y: 0}, {X: 1, Y: 0}, {X: 0, Y: 1}, {X: 1, Y: 1}}, Color: raylib.YELLOW},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 1, Y: 0}, {X: 0, Y: 1}, {X: 1, Y: 1}, {X: 2, Y: 1}}, Color: raylib.PURPLE},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 1, Y: 0}, {X: 2, Y: 0}, {X: 0, Y: 1}, {X: 1, Y: 1}}, Color: raylib.GREEN},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 0, Y: 0}, {X: 1, Y: 0}, {X: 1, Y: 1}, {X: 2, Y: 1}}, Color: raylib.RED},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 0, Y: 0}, {X: 0, Y: 1}, {X: 1, Y: 1}, {X: 2, Y: 1}}, Color: raylib.BLUE},
+	{Blocks: [MAX_BLOCKS]raylib.Vector2{{X: 2, Y: 0}, {X: 0, Y: 1}, {X: 1, Y: 1}, {X: 2, Y: 1}}, Color: raylib.ORANGE},
+}
+
+var board [BOARD_HEIGHT][BOARD_WIDTH]raylib.Color
+
+var curShape Shape
+var curPos raylib.Vector2
+
+var fallTime = c.Float(0)
+var fallSpeed = c.Float(0.2)
+var score = 0
+var scoreText = make([]c.Char, 20)
+var gameOver = false
+
+func genShape() {
+	curShape = SHAPES[raylib.GetRandomValue(c.Int(0), c.Int(6))]
+	curPos = raylib.Vector2{BOARD_WIDTH/2 - 1, 0}
+}
+
+func checkCollision() bool {
+	for i := 0; i < MAX_BLOCKS; i++ {
+		x := int(curPos.X + curShape.Blocks[i].X)
+		y := int(curPos.Y + curShape.Blocks[i].Y)
+		if x < 0 || x >= BOARD_WIDTH || y >= BOARD_HEIGHT || (y >= 0 && board[y][x] != raylib.BLANK) {
+			return true
+		}
+	}
+	return false
+}
+
+func lockShape() {
+	for i := 0; i < MAX_BLOCKS; i++ {
+		x := int(curPos.X + curShape.Blocks[i].X)
+		y := int(curPos.Y + curShape.Blocks[i].Y)
+		if y >= 0 {
+			board[y][x] = curShape.Color
+		}
+	}
+}
+
+func rotateShape() {
+	rotated := curShape
+	for i := 0; i < MAX_BLOCKS; i++ {
+		x := rotated.Blocks[i].X
+		rotated.Blocks[i].X = -rotated.Blocks[i].Y
+		rotated.Blocks[i].Y = x
+	}
+
+	temp := curShape
+	curShape = rotated
+	if checkCollision() {
+		curShape = temp
+	}
+}
+
+func clearLines() int {
+	linesCleared := 0
+	for y := BOARD_HEIGHT - 1; y >= 0; y-- {
+		lineFull := true
+		for x := 0; x < BOARD_WIDTH; x++ {
+			if board[y][x] == raylib.BLANK {
+				lineFull = false
+				break
+			}
+		}
+		if lineFull {
+			for yy := y; yy > 0; yy-- {
+				for x := 0; x < BOARD_WIDTH; x++ {
+					board[yy][x] = board[yy-1][x]
+				}
+			}
+			for x := 0; x < BOARD_WIDTH; x++ {
+				board[0][x] = raylib.BLANK
+			}
+			y += 1
+			linesCleared += 1
+		}
+	}
+	return linesCleared
+}
+
+func keyPressed(key c.Int) bool {
+	return raylib.IsKeyPressed(key) || raylib.IsKeyPressedRepeat(key)
+}
+
+func main() {
+	raylib.InitWindow(SCREENWIDTH, SCREENHEIGHT, c.Str("tetris (powered by raylib + llgo)"))
+	raylib.SetTargetFPS(c.Int(60))
+	genShape()
+	for !raylib.WindowShouldClose() && !gameOver {
+		fallTime += raylib.GetFrameTime()
+		if fallTime >= fallSpeed {
+			fallTime = 0
+			curPos.Y += 1
+			if checkCollision() {
+				curPos.Y -= 1
+				lockShape()
+				linesCleared := clearLines()
+				score += linesCleared * 100
+				genShape()
+				if checkCollision() {
+					gameOver = true
+				}
+			}
+		}
+
+		if keyPressed(raylib.KEY_LEFT) {
+			curPos.X -= 1
+			if checkCollision() {
+				curPos.X += 1
+			}
+		}
+		if keyPressed(raylib.KEY_RIGHT) {
+			curPos.X += 1
+			if checkCollision() {
+				curPos.X -= 1
+			}
+		}
+		if keyPressed(raylib.KEY_SPACE) || keyPressed(raylib.KEY_UP) || keyPressed(raylib.KEY_DOWN) {
+			rotateShape()
+		}
+
+		raylib.BeginDrawing()
+		raylib.ClearBackground(raylib.RAYWHITE)
+		for y := 0; y < BOARD_HEIGHT; y++ {
+			for x := 0; x < BOARD_WIDTH; x++ {
+				raylib.DrawRectangle(c.Int(x*BLOCK_SIZE), c.Int(y*BLOCK_SIZE), c.Int(BLOCK_SIZE-1), c.Int(BLOCK_SIZE-1), board[y][x])
+			}
+		}
+
+		for i := 0; i < MAX_BLOCKS; i++ {
+			raylib.DrawRectangle(c.Int((curPos.X+curShape.Blocks[i].X)*BLOCK_SIZE), c.Int((curPos.Y+curShape.Blocks[i].Y)*BLOCK_SIZE),
+				BLOCK_SIZE-1, BLOCK_SIZE-1, curShape.Color)
+		}
+
+		c.Sprintf(unsafe.SliceData(scoreText), c.Str("Score:%d"), score)
+		raylib.DrawText(unsafe.SliceData(scoreText), 10, 10, 20, raylib.BLACK)
+
+		raylib.EndDrawing()
+	}
+
+	for !raylib.WindowShouldClose() {
+		raylib.BeginDrawing()
+		raylib.ClearBackground(raylib.RAYWHITE)
+		raylib.DrawText(c.Str("Game Over"), SCREENWIDTH/2-50, SCREENHEIGHT/2-10, 20, raylib.RED)
+		raylib.DrawText(unsafe.SliceData(scoreText), SCREENWIDTH/2-50, SCREENHEIGHT/2+10, 20, raylib.BLACK)
+		raylib.EndDrawing()
+	}
+}

c/raylib/raylib.go

@@ -0,0 +1,485 @@
+/*
+ * 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 raylib
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "link: $(pkg-config --libs raylib); -lraylib"
+)
+
+// -----------------------------------------------------------------------------
+
+// Vector2, 2 components
+type Vector2 struct {
+	X float32 // Vector x component
+	Y float32 // Vector y component
+}
+
+// Vector3, 3 components
+type Vector3 struct {
+	X float32 // Vector x component
+	Y float32 // Vector y component
+	Z float32 // Vector z component
+}
+
+// Vector4, 4 components
+type Vector4 struct {
+	X float32 // Vector x component
+	Y float32 // Vector y component
+	Z float32 // Vector z component
+	W float32 // Vector w component
+}
+
+// Quaternion, 4 components (Vector4 alias)
+type Quaternion = Vector4
+
+//----------------------------------------------------------------------------------
+// Enumerators Definition
+
+// System/Window config flags
+// By default all flags are set to 0
+
+// Trace log level
+
+// Keyboard keys (US keyboard layout)
+// required keys for alternative layouts
+const (
+	KEY_NULL = 0 // Key: NULL, used for no key pressed
+
+	// Alphanumeric keys
+	KEY_APOSTROPHE    = 39 // Key: '
+	KEY_COMMA         = 44 // Key: ,
+	KEY_MINUS         = 45 // Key: -
+	KEY_PERIOD        = 46 // Key: .
+	KEY_SLASH         = 47 // Key: /
+	KEY_ZERO          = 48 // Key: 0
+	KEY_ONE           = 49 // Key: 1
+	KEY_TWO           = 50 // Key: 2
+	KEY_THREE         = 51 // Key: 3
+	KEY_FOUR          = 52 // Key: 4
+	KEY_FIVE          = 53 // Key: 5
+	KEY_SIX           = 54 // Key: 6
+	KEY_SEVEN         = 55 // Key: 7
+	KEY_EIGHT         = 56 // Key: 8
+	KEY_NINE          = 57 // Key: 9
+	KEY_SEMICOLON     = 59 // Key: ;
+	KEY_EQUAL         = 61 // Key: =
+	KEY_A             = 65 // Key: A | a
+	KEY_B             = 66 // Key: B | b
+	KEY_C             = 67 // Key: C | c
+	KEY_D             = 68 // Key: D | d
+	KEY_E             = 69 // Key: E | e
+	KEY_F             = 70 // Key: F | f
+	KEY_G             = 71 // Key: G | g
+	KEY_H             = 72 // Key: H | h
+	KEY_I             = 73 // Key: I | i
+	KEY_J             = 74 // Key: J | j
+	KEY_K             = 75 // Key: K | k
+	KEY_L             = 76 // Key: L | l
+	KEY_M             = 77 // Key: M | m
+	KEY_N             = 78 // Key: N | n
+	KEY_O             = 79 // Key: O | o
+	KEY_P             = 80 // Key: P | p
+	KEY_Q             = 81 // Key: Q | q
+	KEY_R             = 82 // Key: R | r
+	KEY_S             = 83 // Key: S | s
+	KEY_T             = 84 // Key: T | t
+	KEY_U             = 85 // Key: U | u
+	KEY_V             = 86 // Key: V | v
+	KEY_W             = 87 // Key: W | w
+	KEY_X             = 88 // Key: X | x
+	KEY_Y             = 89 // Key: Y | y
+	KEY_Z             = 90 // Key: Z | z
+	KEY_LEFT_BRACKET  = 91 // Key: [
+	KEY_BACKSLASH     = 92 // Key: '\'
+	KEY_RIGHT_BRACKET = 93 // Key: ]
+	KEY_GRAVE         = 96 // Key: `
+
+	// Function keys
+	KEY_SPACE         = 32  // Key: Space
+	KEY_ESCAPE        = 256 // Key: Esc
+	KEY_ENTER         = 257 // Key: Enter
+	KEY_TAB           = 258 // Key: Tab
+	KEY_BACKSPACE     = 259 // Key: Backspace
+	KEY_INSERT        = 260 // Key: Ins
+	KEY_DELETE        = 261 // Key: Del
+	KEY_RIGHT         = 262 // Key: Cursor right
+	KEY_LEFT          = 263 // Key: Cursor left
+	KEY_DOWN          = 264 // Key: Cursor down
+	KEY_UP            = 265 // Key: Cursor up
+	KEY_PAGE_UP       = 266 // Key: Page up
+	KEY_PAGE_DOWN     = 267 // Key: Page down
+	KEY_HOME          = 268 // Key: Home
+	KEY_END           = 269 // Key: End
+	KEY_CAPS_LOCK     = 280 // Key: Caps lock
+	KEY_SCROLL_LOCK   = 281 // Key: Scroll down
+	KEY_NUM_LOCK      = 282 // Key: Num lock
+	KEY_PRINT_SCREEN  = 283 // Key: Print screen
+	KEY_PAUSE         = 284 // Key: Pause
+	KEY_F1            = 290 // Key: F1
+	KEY_F2            = 291 // Key: F2
+	KEY_F3            = 292 // Key: F3
+	KEY_F4            = 293 // Key: F4
+	KEY_F5            = 294 // Key: F5
+	KEY_F6            = 295 // Key: F6
+	KEY_F7            = 296 // Key: F7
+	KEY_F8            = 297 // Key: F8
+	KEY_F9            = 298 // Key: F9
+	KEY_F10           = 299 // Key: F10
+	KEY_F11           = 300 // Key: F11
+	KEY_F12           = 301 // Key: F12
+	KEY_LEFT_SHIFT    = 340 // Key: Shift left
+	KEY_LEFT_CONTROL  = 341 // Key: Control left
+	KEY_LEFT_ALT      = 342 // Key: Alt left
+	KEY_LEFT_SUPER    = 343 // Key: Super left
+	KEY_RIGHT_SHIFT   = 344 // Key: Shift right
+	KEY_RIGHT_CONTROL = 345 // Key: Control right
+	KEY_RIGHT_ALT     = 346 // Key: Alt right
+	KEY_RIGHT_SUPER   = 347 // Key: Super right
+	KEY_KB_MENU       = 348 // Key: KB menu
+
+	// Keypad keys
+	KEY_KP_0        = 320 // Key: Keypad 0
+	KEY_KP_1        = 321 // Key: Keypad 1
+	KEY_KP_2        = 322 // Key: Keypad 2
+	KEY_KP_3        = 323 // Key: Keypad 3
+	KEY_KP_4        = 324 // Key: Keypad 4
+	KEY_KP_5        = 325 // Key: Keypad 5
+	KEY_KP_6        = 326 // Key: Keypad 6
+	KEY_KP_7        = 327 // Key: Keypad 7
+	KEY_KP_8        = 328 // Key: Keypad 8
+	KEY_KP_9        = 329 // Key: Keypad 9
+	KEY_KP_DECIMAL  = 330 // Key: Keypad .
+	KEY_KP_DIVIDE   = 331 // Key: Keypad /
+	KEY_KP_MULTIPLY = 332 // Key: Keypad *
+	KEY_KP_SUBTRACT = 333 // Key: Keypad -
+	KEY_KP_ADD      = 334 // Key: Keypad +
+	KEY_KP_ENTER    = 335 // Key: Keypad Enter
+	KEY_KP_EQUAL    = 336 // Key: Keypad =
+
+	// Android key buttons
+	KEY_BACK        = 4  // Key: Android back button
+	KEY_MENU        = 82 // Key: Android menu button
+	KEY_VOLUME_UP   = 24 // Key: Android volume up button
+	KEY_VOLUME_DOWN = 25 // Key: Android volume down button
+)
+
+// Mouse buttons
+
+// Mouse cursor
+
+// Gamepad buttons
+
+// Gamepad axis
+
+// Material map index
+
+// Shader location index
+
+// Shader uniform data type
+
+// Shader attribute data types
+
+// Pixel formats
+
+// Texture parameters: filter mode
+
+// Texture parameters: wrap mode
+
+// Cubemap layouts
+
+// Font type, defines generation method
+
+// Color blending modes (pre-defined)
+
+// Gesture
+
+// Camera system modes
+
+// Camera projection
+
+// N-patch layout
+
+// -----------------------------------------------------------------------------
+// Window-related functions
+
+//go:linkname InitWindow C.InitWindow
+func InitWindow(width, height c.Int, title *c.Char)
+
+//go:linkname CloseWindow C.CloseWindow
+func CloseWindow()
+
+//go:linkname WindowShouldClose C.WindowShouldClose
+func WindowShouldClose() bool
+
+//go:linkname IsWindowReady C.IsWindowReady
+func IsWindowReady() bool
+
+//go:linkname IsWindowFullscreen C.IsWindowFullscreen
+func IsWindowFullscreen() bool
+
+//go:linkname IsWindowHidden C.IsWindowHidden
+func IsWindowHidden() bool
+
+//go:linkname IsWindowMinimized C.IsWindowMinimized
+func IsWindowMinimized() bool
+
+//go:linkname IsWindowMaximized C.IsWindowMaximized
+func IsWindowMaximized() bool
+
+//go:linkname IsWindowFocused C.IsWindowFocused
+func IsWindowFocused() bool
+
+//go:linkname IsWindowResized C.IsWindowResized
+func IsWindowResized() bool
+
+//go:linkname IsWindowState C.IsWindowState
+func IsWindowState(flag c.Int) bool
+
+//go:linkname SetWindowState C.SetWindowState
+func SetWindowState(flags c.Int)
+
+//go:linkname ClearWindowState C.ClearWindowState
+func ClearWindowState(flags c.Int)
+
+//go:linkname ToggleFullscreen C.ToggleFullscreen
+func ToggleFullscreen()
+
+//go:linkname MaximizeWindow C.MaximizeWindow
+func MaximizeWindow()
+
+//go:linkname MinimizeWindow C.MinimizeWindow
+func MinimizeWindow()
+
+//go:linkname RestoreWindow C.RestoreWindow
+func RestoreWindow()
+
+//go:linkname SetWindowIcon C.SetWindowIcon
+func SetWindowIcon(icon Image)
+
+//go:linkname SetWindowIcons C.SetWindowIcons
+func SetWindowIcons(icons *Image, count c.Int)
+
+//go:linkname SetWindowTitle C.SetWindowTitle
+func SetWindowTitle(title *c.Char)
+
+//go:linkname SetWindowPosition C.SetWindowPosition
+func SetWindowPosition(x, y c.Int)
+
+//go:linkname SetWindowMonitor C.SetWindowMonitor
+func SetWindowMonitor(monitor c.Int)
+
+//go:linkname SetWindowMinSize C.SetWindowMinSize
+func SetWindowMinSize(width, height c.Int)
+
+//go:linkname SetWindowSize C.SetWindowSize
+func SetWindowSize(width, height c.Int)
+
+//go:linkname SetWindowOpacity C.SetWindowOpacity
+func SetWindowOpacity(opacity c.Float)
+
+//go:linkname SetWindowFocused C.SetWindowFocused
+func SetWindowFocused()
+
+//go:linkname GetWindowHandle C.GetWindowHandle
+func GetWindowHandle() c.Pointer
+
+//go:linkname GetScreenWidth C.GetScreenWidth
+func GetScreenWidth() c.Int
+
+//go:linkname GetScreenHeight C.GetScreenHeight
+func GetScreenHeight() c.Int
+
+// Get current render width (it considers HiDPI)
+//
+//go:linkname GetRenderWidth C.GetRenderWidth
+func GetRenderWidth() c.Int
+
+// Get current render height (it considers HiDPI)
+//
+//go:linkname GetRenderHeight C.GetRenderHeight
+func GetRenderHeight() c.Int
+
+// Get number of connected monitors
+//
+//go:linkname GetMonitorCount C.GetMonitorCount
+func GetMonitorCount() c.Int
+
+// Get current connected monitor
+//
+//go:linkname GetCurrentMonitor C.GetCurrentMonitor
+func GetCurrentMonitor() c.Int
+
+// Get specified monitor position
+//
+//go:linkname GetMonitorPosition C.GetMonitorPosition
+func GetMonitorPosition(monitor c.Int) Vector2
+
+//go:linkname GetMonitorWidth C.GetMonitorWidth
+func GetMonitorWidth(monitor c.Int) c.Int
+
+//go:linkname GetMonitorHeight C.GetMonitorHeight
+func GetMonitorHeight(monitor c.Int) c.Int
+
+//go:linkname GetMonitorPhysicalWidth C.GetMonitorPhysicalWidth
+func GetMonitorPhysicalWidth(monitor c.Int) c.Int
+
+//go:linkname GetMonitorPhysicalHeight C.GetMonitorPhysicalHeight
+func GetMonitorPhysicalHeight(monitor c.Int) c.Int
+
+//go:linkname GetMonitorRefreshRate C.GetMonitorRefreshRate
+func GetMonitorRefreshRate(monitor c.Int) c.Int
+
+//go:linkname GetWindowPosition C.GetWindowPosition
+func GetWindowPosition() Vector2
+
+//go:linkname GetWindowScaleDPI C.GetWindowScaleDPI
+func GetWindowScaleDPI() Vector2
+
+//go:linkname GetMonitorName C.GetMonitorName
+func GetMonitorName(monitor c.Int) *c.Char
+
+//go:linkname SetClipboardText C.SetClipboardText
+func SetClipboardText(text *c.Char)
+
+//go:linkname GetClipboardText C.GetClipboardText
+func GetClipboardText() *c.Char
+
+// Enable waiting for events on EndDrawing(), no automatic event polling
+//
+//go:linkname EnableEventWaiting C.EnableEventWaiting
+func EnableEventWaiting()
+
+// Disable waiting for events on EndDrawing(), automatic events polling
+//
+//go:linkname DisableEventWaiting C.DisableEventWaiting
+func DisableEventWaiting()
+
+// -----------------------------------------------------------------------------
+// Cursor-related functions
+
+//go:linkname ShowCursor C.ShowCursor
+func ShowCursor()
+
+//go:linkname HideCursor C.HideCursor
+func HideCursor()
+
+//go:linkname IsCursorHidden C.IsCursorHidden
+func IsCursorHidden() bool
+
+//go:linkname EnableCursor C.EnableCursor
+func EnableCursor()
+
+//go:linkname DisableCursor C.DisableCursor
+func DisableCursor()
+
+//go:linkname IsCursorOnScreen C.IsCursorOnScreen
+func IsCursorOnScreen() bool
+
+// -----------------------------------------------------------------------------
+// Shader management functions
+
+// -----------------------------------------------------------------------------
+// Screen-space-related functions
+
+// -----------------------------------------------------------------------------
+// Timing-related functions
+
+// Set target FPS (maximum)
+//
+//go:linkname SetTargetFPS C.SetTargetFPS
+func SetTargetFPS(fps c.Int)
+
+// Returns current FPS
+//
+//go:linkname GetFPS C.GetFPS
+func GetFPS() c.Int
+
+// Returns time in seconds for last frame drawn (delta time)
+//
+//go:linkname GetFrameTime C.GetFrameTime
+func GetFrameTime() c.Float
+
+// Returns elapsed time in seconds since InitWindow()
+//
+//go:linkname GetTime C.GetTime
+func GetTime() c.Double
+
+// -----------------------------------------------------------------------------
+// Custom frame control functions
+
+// NOTE: Those functions are intended for advance users that want full control over the frame processing
+// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
+// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
+
+// -----------------------------------------------------------------------------
+// Random values generation functions
+
+//go:linkname SetRandomSeed C.SetRandomSeed
+func SetRandomSeed(seed c.Uint)
+
+//go:linkname GetRandomValue C.GetRandomValue
+func GetRandomValue(min c.Int, max c.Int) c.Int
+
+// -----------------------------------------------------------------------------
+// Misc. functions
+
+// -----------------------------------------------------------------------------
+// Input-related functions: keyboard
+
+//go:linkname IsKeyPressed C.IsKeyPressed
+func IsKeyPressed(key c.Int) bool
+
+//go:linkname IsKeyPressedRepeat C.IsKeyPressedRepeat
+func IsKeyPressedRepeat(key c.Int) bool
+
+//go:linkname IsKeyDown C.IsKeyDown
+func IsKeyDown(key c.Int) bool
+
+//go:linkname IsKeyReleased C.IsKeyReleased
+func IsKeyReleased(key c.Int) bool
+
+//go:linkname IsKeyUp C.IsKeyUp
+func IsKeyUp(key c.Int) bool
+
+//go:linkname GetKeyPressed C.GetKeyPressed
+func GetKeyPressed() c.Int
+
+//go:linkname GetCharPressed C.GetCharPressed
+func GetCharPressed() c.Int
+
+//go:linkname SetExitKey C.SetExitKey
+func SetExitKey(key c.Int)
+
+// -----------------------------------------------------------------------------
+// Input-related functions: gamepads
+
+// -----------------------------------------------------------------------------
+// Input-related functions: mouse
+
+// -----------------------------------------------------------------------------
+// Input-related functions: touch
+
+// -----------------------------------------------------------------------------
+// Gestures and Touch Handling Functions (Module: rgestures)
+
+// -----------------------------------------------------------------------------

c/raylib/shape.go

@@ -0,0 +1,215 @@
+/*
+ * 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 raylib
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// Color, 4 components, R8G8B8A8 (32bit)
+// R, G, B, A uint8
+type Color uint32
+
+const (
+	LIGHTGRAY = Color(200 | 200<<8 | 200<<16 | 255<<24) // Light Gray
+	GRAY      = Color(130 | 130<<8 | 130<<16 | 255<<24) // Gray
+	DARKGRAY  = Color(80 | 80<<8 | 80<<16 | 255<<24)    // Dark Gray
+	YELLOW    = Color(253 | 249<<8 | 0<<16 | 255<<24)   // Yellow
+	GOLD      = Color(255 | 203<<8 | 0<<16 | 255<<24)   // Gold
+	ORANGE    = Color(255 | 161<<8 | 0<<16 | 255<<24)   // Orange
+	PINK      = Color(255 | 109<<8 | 194<<16 | 255<<24) // Pink
+	RED       = Color(230 | 41<<8 | 55<<16 | 255<<24)   // Red
+	MAROON    = Color(190 | 33<<8 | 55<<16 | 255<<24)   // Maroon
+	GREEN     = Color(0 | 228<<8 | 48<<16 | 255<<24)    // Green
+	LIME      = Color(0 | 158<<8 | 47<<16 | 255<<24)    // Lime
+	DARKGREEN = Color(0 | 117<<8 | 44<<16 | 255<<24)    // Dark Green
+	SKYBLUE   = Color(102 | 191<<8 | 255<<16 | 255<<24) // Sky Blue
+	BLUE      = Color(0 | 121<<8 | 241<<16 | 255<<24)   // Blue
+
+	DARKBLUE   = Color(0 | 82<<8 | 172<<16 | 255<<24)    // Dark Blue
+	PURPLE     = Color(200 | 122<<8 | 255<<16 | 255<<24) // Purple
+	VIOLET     = Color(135 | 60<<8 | 190<<16 | 255<<24)  // Violet
+	DARKPURPLE = Color(112 | 31<<8 | 126<<16 | 255<<24)  // Dark Purple
+	BEIGE      = Color(211 | 176<<8 | 131<<16 | 255<<24) // Beige
+	BROWN      = Color(127 | 106<<8 | 79<<16 | 255<<24)  // Brown
+	DARKBROWN  = Color(76 | 63<<8 | 47<<16 | 255<<24)    // Dark Brown
+
+	WHITE    = Color(255 | 255<<8 | 255<<16 | 255<<24) // White
+	BLACK    = Color(0 | 0<<8 | 0<<16 | 255<<24)       // Black
+	BLANK    = Color(0 | 0<<8 | 0<<16 | 0<<24)         // Blank (Transparent)
+	MAGENTA  = Color(255 | 0<<8 | 255<<16 | 255<<24)   // Magenta
+	RAYWHITE = Color(245 | 245<<8 | 245<<16 | 255<<24) // My own White (raylib logo)
+)
+
+// Image, pixel data stored in CPU memory (RAM)
+type Image struct {
+	Data    c.Pointer // Image raw data
+	Width   c.Int     // Image base width
+	Height  c.Int     // Image base height
+	Mipmaps c.Int     // Mipmap levels, 1 by default
+	Format  c.Int     // Data format (PixelFormat type)
+}
+
+// Camera, defines position/orientation in 3d space
+type Camera3D struct {
+	Position   Vector3 // Camera position
+	Target     Vector3 // Camera target it looks-at
+	Up         Vector3 // Camera up vector (rotation over its axis)
+	Fovy       float32 // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
+	Projection c.Int   // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
+}
+
+type Camera = Camera3D // Camera type fallback, defaults to Camera3D
+
+// Camera2D, defines position/orientation in 2d space
+type Camera2D struct {
+	Offset   Vector2 // Camera offset (displacement from target)
+	Target   Vector2 // Camera target (rotation and zoom origin)
+	Rotation float32 // Camera rotation in degrees
+	Zoom     float32 // Camera zoom (scaling), should be 1.0f by default
+}
+
+// Shader
+type Shader struct {
+	Id   c.Uint // Shader program id
+	Locs *c.Int // Shader locations array (RL_MAX_SHADER_LOCATIONS)
+}
+
+// -----------------------------------------------------------------------------
+// Drawing-related functions
+
+// Set background color (framebuffer clear color)
+//
+//go:linkname ClearBackground C.ClearBackground
+func ClearBackground(color Color)
+
+// Begin drawing (call before drawing anything)
+//
+//go:linkname BeginDrawing C.BeginDrawing
+func BeginDrawing()
+
+// End drawing and swap buffers (call after drawing)
+//
+//go:linkname EndDrawing C.EndDrawing
+func EndDrawing()
+
+// Begin 2D mode with custom camera (2D)
+//
+//go:linkname BeginMode2D C.BeginMode2D
+func BeginMode2D(camera Camera2D)
+
+// End mode (2D)
+//
+//go:linkname EndMode2D C.EndMode2D
+func EndMode2D()
+
+// Begin 3D mode with custom camera (3D)
+//
+//go:linkname BeginMode3D C.BeginMode3D
+func BeginMode3D(camera Camera3D)
+
+// End mode (3D)
+//
+//go:linkname EndMode3D C.EndMode3D
+func EndMode3D()
+
+// Begin drawing to render texture
+//-go:linkname BeginTextureMode C.BeginTextureMode
+//func BeginTextureMode(target RenderTexture2D)
+
+// End drawing to render texture
+//
+//go:linkname EndTextureMode C.EndTextureMode
+func EndTextureMode()
+
+// Begin custom shader drawing
+//
+//go:linkname BeginShaderMode C.BeginShaderMode
+func BeginShaderMode(shader Shader)
+
+// End custom shader drawing (use default shader)
+//
+//go:linkname EndShaderMode C.EndShaderMode
+func EndShaderMode()
+
+// Color blending modes (pre-defined)
+type BlendMode c.Int
+
+const (
+	BLEND_ALPHA             BlendMode = iota // Blend textures considering alpha (default)
+	BLEND_ADDITIVE                           // Blend textures adding colors
+	BLEND_MULTIPLIED                         // Blend textures multiplying colors
+	BLEND_ADD_COLORS                         // Blend textures adding colors (alternative)
+	BLEND_SUBTRACT_COLORS                    // Blend textures subtracting colors (alternative)
+	BLEND_ALPHA_PREMULTIPLY                  // Blend premultiplied textures considering alpha
+	BLEND_CUSTOM                             // Blend textures using custom src/dst factors (use rlSetBlendFactors())
+	BLEND_CUSTOM_SEPARATE                    // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate())
+)
+
+// Begin blending mode (alpha, additive, multiplied, subtract, custom)
+//
+//go:linkname BeginBlendMode C.BeginBlendMode
+func BeginBlendMode(mode BlendMode)
+
+// End blending mode (reset to default: alpha blending)
+//
+//go:linkname EndBlendMode C.EndBlendMode
+func EndBlendMode()
+
+// Begin scissor mode (define screen area for following drawing)
+//
+//go:linkname BeginScissorMode C.BeginScissorMode
+func BeginScissorMode(x, y, width, height c.Int)
+
+// End scissor mode
+//
+//go:linkname EndScissorMode C.EndScissorMode
+func EndScissorMode()
+
+// -----------------------------------------------------------------------------
+// VR stereo config functions for VR simulator
+
+// -----------------------------------------------------------------------------
+// Camera System Functions (Module: rcamera)
+
+// Update camera position for selected mode
+//
+//go:linkname UpdateCamera C.UpdateCamera
+func UpdateCamera(camera *Camera, mode c.Int)
+
+// Update camera movement/rotation
+//
+//go:linkname UpdateCameraPro C.UpdateCameraPro
+func UpdateCameraPro(camera *Camera, movement, rotation Vector3, zoom float32)
+
+// -----------------------------------------------------------------------------
+
+// Draw a color-filled rectangle
+//
+//go:linkname DrawRectangle C.DrawRectangle
+func DrawRectangle(posX, posY, width, height c.Int, color Color)
+
+// Draw text (using default font)
+//
+//go:linkname DrawText C.DrawText
+func DrawText(text *c.Char, posX, posY, fontSize c.Int, color Color)
+
+// -----------------------------------------------------------------------------

c/raylib/utils.go

@@ -0,0 +1,67 @@
+/*
+ * 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 raylib
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+// -----------------------------------------------------------------------------
+
+// Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
+//
+//go:linkname TraceLog C.TraceLog
+func TraceLog(logLevel int, text *c.Char, __llgo_va_list ...any)
+
+// Set the current threshold (minimum) log level
+//
+//go:linkname SetTraceLogLevel C.SetTraceLogLevel
+func SetTraceLogLevel(logLevel int)
+
+// -----------------------------------------------------------------------------
+// Set custom callbacks
+
+// -----------------------------------------------------------------------------
+// Files management functions
+
+// -----------------------------------------------------------------------------
+// File system functions
+
+// Check if file exists
+//
+//go:linkname FileExists C.FileExists
+func FileExists(fileName *c.Char) bool
+
+// Check if a directory path exists
+//
+//go:linkname DirectoryExists C.DirectoryExists
+func DirectoryExists(dirPath *c.Char) bool
+
+// Check file extension (including point: .png, .wav)
+//
+//go:linkname IsFileExtension C.IsFileExtension
+func IsFileExtension(fileName *c.Char, ext *c.Char) bool
+
+// -----------------------------------------------------------------------------
+// Compression/Encoding functionality
+
+// -----------------------------------------------------------------------------
+// Automation events functionality
+
+// -----------------------------------------------------------------------------

c/socket/socket.go

@@ -0,0 +1,144 @@
+/*
+ * 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 socket
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = true
+)
+
+const (
+	AF_UNSPEC          = 0       // unspecified
+	AF_UNIX            = 1       // local to host (pipes)
+	AF_LOCAL           = AF_UNIX // backward compatibility
+	AF_INET            = 2       // internetwork: UDP, TCP, etc.
+	AF_IMPLINK         = 3       // arpanet imp addresses
+	AF_PUP             = 4       // pup protocols: e.g. BSP
+	AF_CHAOS           = 5       // mit CHAOS protocols
+	AF_NS              = 6       // XEROX NS protocols
+	AF_ISO             = 7       // ISO protocols
+	AF_OSI             = AF_ISO
+	AF_ECMA            = 8       // European computer manufacturers
+	AF_DATAKIT         = 9       // datakit protocols
+	AF_CCITT           = 10      // CCITT protocols, X.25 etc
+	AF_SNA             = 11      // IBM SNA
+	AF_DECnet          = 12      // DECnet
+	AF_DLI             = 13      // DEC Direct data link interface
+	AF_LAT             = 14      // LAT
+	AF_HYLINK          = 15      // NSC Hyperchannel
+	AF_APPLETALK       = 16      // Apple Talk
+	AF_ROUTE           = 17      // Internal Routing Protocol
+	AF_LINK            = 18      // Link layer interface
+	pseudo_AF_XTP      = 19      // eXpress Transfer Protocol (no AF)
+	AF_COIP            = 20      // connection-oriented IP, aka ST II
+	AF_CNT             = 21      // Computer Network Technology
+	pseudo_AF_RTIP     = 22      // Help Identify RTIP packets
+	AF_IPX             = 23      // Novell Internet Protocol
+	AF_SIP             = 24      // Simple Internet Protocol
+	pseudo_AF_PIP      = 25      // Help Identify PIP packets
+	AF_NDRV            = 27      // Network Driver 'raw' access
+	AF_ISDN            = 28      // Integrated Services Digital Network
+	AF_E164            = AF_ISDN // CCITT E.164 recommendation
+	pseudo_AF_KEY      = 29      // Internal key-management function
+	AF_INET6           = 30      // IPv6
+	AF_NATM            = 31      // native ATM access
+	AF_SYSTEM          = 32      // Kernel event messages
+	AF_NETBIOS         = 33      // NetBIOS
+	AF_PPP             = 34      // PPP communication protocol
+	pseudo_AF_HDRCMPLT = 35      // Used by BPF to not rewrite headers in interface output routine
+	AF_RESERVED_36     = 36      // Reserved for internal usage
+	AF_IEEE80211       = 37      // IEEE 802.11 protocol
+	AF_UTUN            = 38
+	AF_VSOCK           = 40 // VM Sockets
+	AF_MAX             = 41
+)
+
+const (
+	SOCK_STREAM    = 1 // stream socket
+	SOCK_DGRAM     = 2 // datagram socket
+	SOCK_RAW       = 3 // raw-protocol interface
+	SOCK_RDM       = 4 // reliably-delivered message
+	SOCK_SEQPACKET = 5 // sequenced packet stream
+)
+
+// (TODO) merge to inet
+const INET_ADDRSTRLEN = 16
+
+type SockaddrIn struct {
+	Len    uint8
+	Family uint8
+	Port   uint16
+	Addr   InAddr
+	Zero   [8]c.Char
+}
+
+type InAddr struct {
+	Addr c.Uint
+}
+
+type SockAddr struct {
+	Len    uint8
+	Family uint8
+	Data   [14]c.Char
+}
+
+// (TODO) merge to netdb
+type Hostent struct {
+	Name     *c.Char  // official name of host
+	Aliases  **c.Char // null-terminated array of alternate names for the host
+	AddrType c.Int    // host address type
+	Length   c.Int    // length of address
+	AddrList **c.Char // null-terminated array of addresses for the host
+}
+
+//go:linkname Socket C.socket
+func Socket(domain c.Int, typ c.Int, protocol c.Int) c.Int
+
+//go:linkname Bind C.bind
+func Bind(sockfd c.Int, addr *SockaddrIn, addrlen c.Uint) c.Int
+
+//go:linkname Connect C.connect
+func Connect(sockfd c.Int, addr *SockAddr, addrlen c.Uint) c.Int
+
+//go:linkname Listen C.listen
+func Listen(sockfd c.Int, backlog c.Int) c.Int
+
+//go:linkname Accept C.accept
+func Accept(sockfd c.Int, addr *SockaddrIn, addrlen *c.Uint) c.Int
+
+// (TODO) merge to netdb
+//
+//go:linkname GetHostByName C.gethostbyname
+func GetHostByName(name *c.Char) *Hostent
+
+// (TODO) merge to inet
+//
+//go:linkname InetNtop C.inet_ntop
+func InetNtop(af c.Int, src c.Pointer, dst *c.Char, size c.Uint) *c.Char
+
+func SwapInt16(data uint16) uint16 {
+	return (data << 8) | (data >> 8)
+}
+
+func Htons(x uint16) uint16 {
+	return SwapInt16(x)
+}

c/sync/atomic/atomic.go

@@ -18,7 +18,6 @@ package atomic
 
 import (
 	"unsafe"
-	_ "unsafe"
 )
 
 const (

c/syscall/syscall.go

@@ -0,0 +1,27 @@
+/*
+ * 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 syscall
+
+const (
+	LLGoPackage = "decl"
+)
+
+type Errno = uintptr
+
+// A Signal is a number describing a process signal.
+// It implements the os.Signal interface.
+type Signal = int

c/syscall/unix/at_sysnum_darwin.go

@@ -0,0 +1,10 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package unix
+
+const AT_REMOVEDIR = 0x80
+const AT_SYMLINK_NOFOLLOW = 0x0020
+
+const UTIME_OMIT = -0x2