Merge pull request #506 from xushiwei/q

_wrap: llgo_check (to be continued)

.github/workflows/go.yml

@@ -5,9 +5,9 @@ name: Go
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ "*" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "*" ]
 
 jobs:
 
@@ -15,14 +15,14 @@ jobs:
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest]
-        llvm: [17]
+        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')
@@ -32,10 +32,10 @@ jobs:
       - name: Install LLVM ${{ matrix.llvm }} and libgc-dev
         if: startsWith(matrix.os, 'ubuntu')
         run: |
-          echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{ matrix.llvm }} main' | sudo tee /etc/apt/sources.list.d/llvm.list
+          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ matrix.llvm }} main" | sudo tee /etc/apt/sources.list.d/llvm.list
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
           sudo apt-get update
-          sudo apt-get install --no-install-recommends clang-${{ matrix.llvm }} llvm-${{ matrix.llvm }}-dev libgc-dev
+          sudo apt-get install -y llvm-${{ matrix.llvm }}-dev clang-${{ matrix.llvm }} lld-${{ matrix.llvm }} pkg-config libgc-dev libcjson-dev libsqlite3-dev python3.11-dev
           echo /usr/lib/llvm-${{ matrix.llvm }}/bin >> $GITHUB_PATH
     
       - name: Clang information
@@ -53,10 +53,11 @@ jobs:
         run: go build -v ./...
 
       - name: Test
-        if: matrix.os != 'ubuntu-latest'
+        if: matrix.os != 'macos-latest'
         run: go test -v ./...
+
       - name: Test with coverage
-        if: matrix.os == 'ubuntu-latest'
+        if: matrix.os == 'macos-latest'
         run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
 
       - name: Install

.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_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,9 +10,39 @@ 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:
+
+* 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 standard libary support
 
+You can import a 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/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)
+
+Here is a simple example:
+
 ```go
 package main
 
@@ -34,13 +64,10 @@ The `_demo` directory contains some C standard libary related demos (it start wi
 To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
 
 ```sh
-export LLGOROOT=`pwd`
 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.
-
 
 ## Python support
 
@@ -48,36 +75,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)
 
-Here is an example using the Python `math` library:
+Note: For third-party libraries (such as pandas and pytorch), you still need to install the library files.
+
+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:
 
@@ -85,9 +124,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() {
@@ -102,7 +141,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)
 }
 ```
 
@@ -115,38 +154,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:
+To run these demos (If you haven't installed `llgo` yet, please refer to [How to install](#how-to-install)):
 
 ```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/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/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:
-
-```sh
-export LLGOROOT=`pwd`
 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,38 +168,38 @@ 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/inih](https://pkg.go.dev/github.com/goplus/llgo/c/inih)
+* [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/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)
 
 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)
-* recover (Not supported yet)
-* chan (Not supported yet)
-* generics (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)
-* [errors](_demo/errors/errors.go): demo to implement error interface
-* [defer](_demo/defer/defer.go): defer demo
+* [errors](_cmptest/errors/errors.go): demo to implement error interface
+* [defer](_cmptest/defer/defer.go): defer demo
 * [goroutine](_demo/goroutine/goroutine.go): goroutine demo
 
 
 ## Defer
 
-LLGo defer does not support usage in loops. This is not a bug but a feature, because we think that using defer in a loop is a very unrecommended practice.
+LLGo `defer` does not support usage in loops. This is not a bug but a feature, because we think that using `defer` in a loop is a very unrecommended practice.
 
 
 ### Garbage Collection (GC)
@@ -207,8 +221,35 @@ Here are the Go packages that can be imported correctly:
 * [unicode](https://pkg.go.dev/unicode)
 * [unicode/utf8](https://pkg.go.dev/unicode/utf8)
 * [unicode/utf16](https://pkg.go.dev/unicode/utf16)
+* [math](https://pkg.go.dev/math)
+* [math/bits](https://pkg.go.dev/math/bits)
+* [math/cmplx](https://pkg.go.dev/math/cmplx)
+* [sort](https://pkg.go.dev/sort)
+* [strconv](https://pkg.go.dev/strconv)
+* [sync/atomic](https://pkg.go.dev/sync/atomic)
+* [sync](https://pkg.go.dev/sync) (partially)
+* [syscall](https://pkg.go.dev/syscall) (partially)
+* [errors](https://pkg.go.dev/errors) (partially)
+* [io](https://pkg.go.dev/io) (partially)
+* [io/fs](https://pkg.go.dev/io/fs) (partially)
+* [os](https://pkg.go.dev/os) (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 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))
+
 ## How to install
 
 Follow these steps to generate the `llgo` command (its usage is the same as the `go` command):
@@ -216,21 +257,23 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 ### on macOS
 
 ```sh
-brew update  # execute if needed
-brew install libgc
-brew install llvm@17
-go install -v ./...
+brew update # execute if needed
+brew install llvm@18 pkg-config libgc
+brew install cjson sqlite python@3.12 # optional
+export PATH=$(brew --prefix llvm@18)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
-### on Linux
+### on Linux (Debian/Ubuntu)
 
 ```sh
-echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-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 libgc-dev
-sudo apt-get install --no-install-recommends llvm-17-dev
-go install -v ./...
+sudo apt-get update # execute if needed
+sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev
+sudo apt-get install -y libcjson-dev libsqlite3-dev python3.12-dev # optional
+export PATH=/usr/lib/llvm-18/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
+go install -v github.com/goplus/llgo/cmd/llgo@latest
 ```
 
 ### on Windows
@@ -249,7 +292,9 @@ TODO
 How do I generate these tools?
 
 ```sh
-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/errors/errors.go

@@ -17,6 +17,5 @@ func (e *errorString) Error() string {
 
 func main() {
 	err := New("an error")
-	println(err)
 	println(err.Error())
 }

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

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/goplus/llgo/_demo/interf/foo"
+	"github.com/goplus/llgo/_cmptest/interf/foo"
 )
 
 func Foo() any {

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

@@ -0,0 +1,13 @@
+package main
+
+import "reflect"
+
+func main() {
+	tyIntSlice := reflect.SliceOf(reflect.TypeOf(0))
+	v := reflect.Zero(tyIntSlice)
+	v = reflect.Append(v, reflect.ValueOf(1), reflect.ValueOf(2), reflect.ValueOf(3))
+	for i, n := 0, v.Len(); i < n; i++ {
+		item := v.Index(i)
+		println(item.Int())
+	}
+}

_cmptest/rtype/rtype.go

@@ -0,0 +1,14 @@
+package main
+
+import "reflect"
+
+func main() {
+	tyIntSlice := reflect.SliceOf(reflect.TypeOf(0))
+	println(tyIntSlice.String())
+
+	v := reflect.Zero(tyIntSlice)
+	println(v.Len())
+
+	v = reflect.ValueOf(100)
+	println(v.Int())
+}

_cmptest/sortdemo/sort.go

@@ -0,0 +1,23 @@
+package main
+
+import "sort"
+
+func main() {
+	vals := []int{32, 58, 25, 92, 45, 78}
+	sort.Ints(vals)
+	for _, v := range vals {
+		println(v)
+	}
+
+	texts := []string{"apple", "banana", "cherry", "date", "elderberry", "fig"}
+	sort.Slice(texts, func(i, j int) bool {
+		leni, lenj := len(texts[i]), len(texts[j])
+		if leni != lenj {
+			return leni < lenj
+		}
+		return texts[i] < texts[j]
+	})
+	for _, v := range texts {
+		println(v)
+	}
+}

_cmptest/strconv/strconv.go

@@ -0,0 +1,7 @@
+package main
+
+import "strconv"
+
+func main() {
+	println(strconv.Itoa(-123))
+}

_cmptest/syscall/syscall.go

@@ -0,0 +1,11 @@
+package main
+
+import "syscall"
+
+func main() {
+	wd, err := syscall.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	println("cwd:", wd)
+}

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

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c/sync/atomic"
+)
+
+func main() {
+	var v int64
+
+	atomic.Store(&v, 100)
+	println("store:", atomic.Load(&v))
+
+	ret := atomic.Add(&v, 1)
+	println("ret:", ret, "v:", v)
+
+	ret, _ = atomic.CompareAndExchange(&v, 100, 102)
+	println("ret:", ret, "vs 100, v:", v)
+
+	ret, _ = atomic.CompareAndExchange(&v, 101, 102)
+	println("ret:", ret, "vs 101, v:", v)
+
+	ret = atomic.Sub(&v, 1)
+	println("ret:", ret, "v:", v)
+}

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

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"math/cmplx"
+)
+
+func main() {
+	println("abs(3+4i):", cmplx.Abs(3+4i))
+}

_demo/cppintf/cppintf.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"github.com/goplus/llgo/_demo/cppintf/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{
+			Vptr: &foo.CallbackVtbl{
+				Val:  c.Func((*Bar).getA),
+				Calc: c.Func((*Bar).sqrt),
+			},
+		},
+		a: a,
+	}
+}
+
+func (p *Bar) getA() c.Int {
+	return p.a
+}
+
+func (p *Bar) sqrt(v float64) float64 {
+	return math.Sqrt(v)
+}
+
+func main() {
+	bar := NewBar(1)
+	foo.F(&bar.Callback)
+	foo.G(&bar.Callback)
+}

_demo/cppintf/foo/bar/bar.cpp

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

_demo/cppintf/foo/foo.go

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

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

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
+)
+
+func main() {
+	wd := os.Getcwd(c.Alloca(os.PATH_MAX), os.PATH_MAX)
+	c.Printf(c.Str("cwd: %s\n"), wd)
+}

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

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

_demo/math/math.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"math"
+)
+
+func main() {
+	println(math.Sqrt(2))
+	println(math.Abs(-1.2))
+	println(math.Ldexp(1.2, 3))
+}

_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/internal/runtime/bdwgc"
+	"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/bdwgc/bdwgc.go

@@ -23,7 +23,7 @@ import (
 )
 
 const (
-	LLGoPackage = "link: $LLGO_LIB_BDWGC; $(pkg-config --libs bdw-gc); -lgc"
+	LLGoPackage = "link: $(pkg-config --libs bdw-gc); -lgc"
 )
 
 // -----------------------------------------------------------------------------
@@ -99,3 +99,5 @@ func StartIncrementalCollection()
 
 //go:linkname CollectALittle C.GC_collect_a_little
 func CollectALittle()
+
+// -----------------------------------------------------------------------------

c/bitcast/_cast/cast.c

@@ -0,0 +1,17 @@
+typedef union {
+    double d;
+    float  f;
+    long   v;
+} castUnion;
+
+double llgoToFloat64(long v) {
+    castUnion k;
+    k.v = v;
+    return k.d;
+}
+
+float llgoToFloat32(long v) {
+    castUnion k;
+    k.v = v;
+    return k.f;
+}

c/bitcast/bitcast.go

@@ -0,0 +1,30 @@
+/*
+ * 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 bitcast
+
+import _ "unsafe"
+
+const (
+	LLGoFiles   = "_cast/cast.c"
+	LLGoPackage = "link"
+)
+
+//go:linkname ToFloat64 C.llgoToFloat64
+func ToFloat64(v uintptr) float64
+
+//go:linkname ToFloat32 C.llgoToFloat32
+func ToFloat32(v uintptr) float32

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,17 +28,22 @@ const (
 )
 
 type (
-	Char      = int8
-	Int       = C.int
-	Uint      = C.uint
-	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 {
@@ -45,8 +53,11 @@ type integer interface {
 //go:linkname Str llgo.cstr
 func Str(string) *Char
 
+//go:linkname Func llgo.funcAddr
+func Func(any) Pointer
+
 // llgo:link Advance llgo.advance
-func Advance[PtrT any](ptr PtrT, offset int) PtrT { return ptr }
+func Advance[PtrT any, I integer](ptr PtrT, offset I) PtrT { return ptr }
 
 // llgo:link Index llgo.index
 func Index[T any, I integer](ptr *T, offset I) T { return *ptr }
@@ -57,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
 
@@ -66,14 +84,85 @@ func Free(ptr Pointer)
 //go:linkname Memcpy C.memcpy
 func Memcpy(dst, src Pointer, n uintptr) Pointer
 
+//go:linkname Memmove C.memmove
+func Memmove(dst, src Pointer, n uintptr) Pointer
+
 //go:linkname Memset C.memset
 func Memset(s Pointer, c Int, n uintptr) Pointer
 
+//go:linkname Memchr C.memchr
+func Memchr(s Pointer, c Int, n uintptr) Pointer
+
+//go:linkname Memcmp C.memcmp
+func Memcmp(s1, s2 Pointer, n uintptr) Int
+
 // -----------------------------------------------------------------------------
 
+//go:linkname Strlen C.strlen
+func Strlen(s *Char) uintptr
+
+//go:linkname Strcpy C.strcpy
+func Strcpy(dst, src *Char) *Char
+
+//go:linkname Strncpy C.strncpy
+func Strncpy(dst, src *Char, n uintptr) *Char
+
+//go:linkname Strcat C.strcat
+func Strcat(dst, src *Char) *Char
+
+//go:linkname Strncat C.strncat
+func Strncat(dst, src *Char, n uintptr) *Char
+
+//go:linkname Strcmp C.strcmp
+func Strcmp(s1, s2 *Char) Int
+
+//go:linkname Strncmp C.strncmp
+func Strncmp(s1, s2 *Char, n uintptr) Int
+
+//go:linkname Strchr C.strchr
+func Strchr(s *Char, c Int) *Char
+
+//go:linkname Strrchr C.strrchr
+func Strrchr(s *Char, c Int) *Char
+
+//go:linkname Strstr C.strstr
+func Strstr(s1, s2 *Char) *Char
+
+//go:linkname Strdup C.strdup
+func Strdup(s *Char) *Char
+
+//go:linkname Strndup C.strndup
+func Strndup(s *Char, n uintptr) *Char
+
+//go:linkname Strtok C.strtok
+func Strtok(s, delim *Char) *Char
+
+//go:linkname Strerror C.strerror
+func Strerror(errnum Int) *Char
+
+//go:linkname Sprintf C.sprintf
+func Sprintf(s *Char, format *Char, __llgo_va_list ...any) Int
+
+//go:linkname Snprintf C.snprintf
+func Snprintf(s *Char, n uintptr, format *Char, __llgo_va_list ...any) Int
+
+//go:linkname Vsnprintf C.vsnprintf
+func Vsnprintf(s *Char, n uintptr, format *Char, ap Pointer) Int
+
+// -----------------------------------------------------------------------------
+
+// GoString converts a C string to a Go string.
+// TODO(xsw): any => int
+//
+//go:linkname GoString llgo.string
+func GoString(cstr *Char, __llgo_va_list /* n */ ...any) string
+
 //go:linkname GoStringData llgo.stringData
 func GoStringData(string) *Char
 
+//go:linkname GoDeferData llgo.deferData
+func GoDeferData() Pointer
+
 // -----------------------------------------------------------------------------
 
 //go:linkname AllocaSigjmpBuf llgo.sigjmpbuf
@@ -103,6 +192,11 @@ func Qsort(base Pointer, count, elem uintptr, compar func(a, b Pointer) Int)
 
 // -----------------------------------------------------------------------------
 
+//go:linkname Atoi C.atoi
+func Atoi(s *Char) Int
+
+// -----------------------------------------------------------------------------
+
 //go:linkname Printf C.printf
 func Printf(format *Char, __llgo_va_list ...any) Int
 
@@ -121,10 +215,14 @@ 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 Remove C.remove
-func Remove(path *Char) Int
+//go:linkname Fclose C.fclose
+func Fclose(fp FilePtr) Int
+
+//go:linkname Perror C.perror
+func Perror(s *Char)
 
 // -----------------------------------------------------------------------------
 
@@ -171,6 +269,3 @@ func GetoptLong(argc Int, argv **Char, optstring *Char, longopts *Option, longin
 func GetoptLongOnly(argc Int, argv **Char, optstring *Char, longopts *Option, longindex *Int) Int
 
 // -----------------------------------------------------------------------------
-
-//go:linkname Atoi C.atoi
-func Atoi(s *Char) Int

c/cjson/README.md

@@ -1,22 +1,18 @@
 LLGo wrapper of DaveGamble/cJSON
 =====
-[![Build Status](https://github.com/goplus/cjson/actions/workflows/go.yml/badge.svg)](https://github.com/goplus/cjson/actions/workflows/go.yml)
-[![GitHub release](https://img.shields.io/github/v/tag/goplus/cjson.svg?label=release)](https://github.com/goplus/cjson/releases)
-[![GoDoc](https://pkg.go.dev/badge/github.com/goplus/cjson.svg)](https://pkg.go.dev/github.com/goplus/cjson)
-[![Compiler](https://img.shields.io/badge/compiler-llgo-darkgreen.svg)](https://github.com/goplus/llgo)
-[![Language](https://img.shields.io/badge/language-Go+-blue.svg)](https://github.com/goplus/gop)
 
 ## How to install
 
+### on macOS (Homebrew)
+
 ```sh
-git clone https://github.com/goplus/cjson.git
-cd cjson
-git submodule init
-git submodule update
-mkdir build.dir
-cd build.dir
-cmake ../cJSON
-sudo make install
+brew install cjson 
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+apt-get install -y libcjson-dev
 ```
 
 ## Demos

c/cjson/cjson.go

@@ -23,7 +23,7 @@ import (
 )
 
 const (
-	LLGoPackage = "link: cjson"
+	LLGoPackage = "link: $(pkg-config --libs libcjson); -lcjson"
 )
 
 // llgo:type C

c/clang/_demo/castdump/astdump.go

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

c/clang/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 C.clang_getCString
+func (String) CStr() *c.Char { return nil }
+
+/**
+ * Free the given string.
+ */
+// llgo:link C.clang_disposeString
+func (String) Dispose() {}
+
+type StringSet struct {
+	Strings *String
+	Count   c.Uint
+}
+
+/**
+ * Free the given string set.
+ */
+// llgo:link C.clang_disposeStringSet
+func (*StringSet) Dispose() {}

c/clang/clang.go

@@ -0,0 +1,266 @@
+/*
+ * 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 (
+	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:linke (*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 C.clang_getCursorSpelling
+func (Cursor) String() (ret String) {
+	return
+}
+
+/**
+ * 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 VisitChildren C.clang_visitChildren
+func VisitChildren(
+	cusor Cursor,
+	visitor func(cursor, parent Cursor, clientData ClientData) ChildVisitResult,
+	clientData ClientData) c.Uint {
+	return 0
+}

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,17 @@
+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")
+	}
+}

c/lua/_demo/loadcall/loadcall.go

@@ -0,0 +1,22 @@
+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")
+	}
+
+}

c/lua/_demo/stack/stack.go

@@ -0,0 +1,79 @@
+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"))
+}

c/lua/_demo/table/table.go

@@ -0,0 +1,51 @@
+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)
+
+}

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/cmplx/complex.go

@@ -0,0 +1,151 @@
+/*
+ * 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 cmplx
+
+import (
+	_ "unsafe"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Abs C.cabs
+func Abs(z complex128) float64
+
+//go:linkname Acos C.cacos
+func Acos(z complex128) complex128
+
+//go:linkname Acosh C.cacosh
+func Acosh(z complex128) complex128
+
+//go:linkname Asin C.casin
+func Asin(z complex128) complex128
+
+//go:linkname Asinh C.casinh
+func Asinh(z complex128) complex128
+
+//go:linkname Atan C.catan
+func Atan(z complex128) complex128
+
+//go:linkname Atanh C.catanh
+func Atanh(z complex128) complex128
+
+//go:linkname Cos C.ccos
+func Cos(z complex128) complex128
+
+//go:linkname Cosh C.ccosh
+func Cosh(z complex128) complex128
+
+//go:linkname Exp C.cexp
+func Exp(z complex128) complex128
+
+//go:linkname Log C.clog
+func Log(z complex128) complex128
+
+//go:linkname Log10 C.clog10
+func Log10(z complex128) complex128
+
+//go:linkname Arg C.carg
+func Arg(z complex128) float64
+
+//go:linkname Phase C.carg
+func Phase(z complex128) float64
+
+//go:linkname Pow C.cpow
+func Pow(x, y complex128) complex128
+
+//go:linkname Sin C.csin
+func Sin(z complex128) complex128
+
+//go:linkname Sinh C.csinh
+func Sinh(z complex128) complex128
+
+//go:linkname Sqrt C.csqrt
+func Sqrt(z complex128) complex128
+
+//go:linkname Tan C.ctan
+func Tan(z complex128) complex128
+
+//go:linkname Tanh C.ctanh
+func Tanh(z complex128) complex128
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Absf C.cabsf
+func Absf(z complex64) float32
+
+//go:linkname Acosf C.cacosf
+func Acosf(z complex64) complex64
+
+//go:linkname Acoshf C.cacoshf
+func Acoshf(z complex64) complex64
+
+//go:linkname Asinf C.casinf
+func Asinf(z complex64) complex64
+
+//go:linkname Asinhf C.casinhf
+func Asinhf(z complex64) complex64
+
+//go:linkname Atanf C.catanf
+func Atanf(z complex64) complex64
+
+//go:linkname Atanhf C.catanhf
+func Atanhf(z complex64) complex64
+
+//go:linkname Cosf C.ccosf
+func Cosf(z complex64) complex64
+
+//go:linkname Coshf C.ccoshf
+func Coshf(z complex64) complex64
+
+//go:linkname Expf C.cexpf
+func Expf(z complex64) complex64
+
+//go:linkname Logf C.clogf
+func Logf(z complex64) complex64
+
+//go:linkname Log10f C.clog10f
+func Log10f(z complex64) complex64
+
+//go:linkname Argf C.cargf
+func Argf(z complex64) float32
+
+//go:linkname Phasef C.cargf
+func Phasef(z complex64) float32
+
+//go:linkname Powf C.cpowf
+func Powf(x, y complex64) complex64
+
+//go:linkname Sinf C.csinf
+func Sinf(z complex64) complex64
+
+//go:linkname Sinhf C.csinhf
+func Sinhf(z complex64) complex64
+
+//go:linkname Sqrtf C.csqrtf
+func Sqrtf(z complex64) complex64
+
+//go:linkname Tanf C.ctanf
+func Tanf(z complex64) complex64
+
+//go:linkname Tanhf C.ctanhf
+func Tanhf(z complex64) complex64
+
+// -----------------------------------------------------------------------------

c/math/math.go

@@ -0,0 +1,333 @@
+/*
+ * 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 math
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Acos C.acos
+func Acos(x float64) float64
+
+//go:linkname Acosh C.acosh
+func Acosh(x float64) float64
+
+//go:linkname Asin C.asin
+func Asin(x float64) float64
+
+//go:linkname Asinh C.asinh
+func Asinh(x float64) float64
+
+//go:linkname Atan C.atan
+func Atan(x float64) float64
+
+//go:linkname Atan2 C.atan2
+func Atan2(y, x float64) float64
+
+//go:linkname Atanh C.atanh
+func Atanh(x float64) float64
+
+//go:linkname Cbrt C.cbrt
+func Cbrt(x float64) float64
+
+//go:linkname Ceil C.ceil
+func Ceil(x float64) float64
+
+//go:linkname Cos C.cos
+func Cos(x float64) float64
+
+//go:linkname Cosh C.cosh
+func Cosh(x float64) float64
+
+//go:linkname Copysign C.copysign
+func Copysign(x, y float64) float64
+
+//go:linkname Erf C.erf
+func Erf(x float64) float64
+
+//go:linkname Erfc C.erfc
+func Erfc(x float64) float64
+
+//go:linkname Exp C.exp
+func Exp(x float64) float64
+
+//go:linkname Exp2 C.exp2
+func Exp2(x float64) float64
+
+//go:linkname Expm1 C.expm1
+func Expm1(x float64) float64
+
+//go:linkname Fdim C.fdim
+func Fdim(x, y float64) float64
+
+//go:linkname Floor C.floor
+func Floor(x float64) float64
+
+//go:linkname Fma C.fma
+func Fma(x, y, z float64) float64
+
+//go:linkname Fmax C.fmax
+func Fmax(x, y float64) float64
+
+//go:linkname Fmin C.fmin
+func Fmin(x, y float64) float64
+
+//go:linkname Fmod C.fmod
+func Fmod(x, y float64) float64
+
+//go:linkname Frexp C.frexp
+func Frexp(x float64, exp *c.Int) float64
+
+//go:linkname Gamma C.gamma
+func Gamma(x float64) float64
+
+//go:linkname Hypot C.hypot
+func Hypot(x, y float64) float64
+
+//go:linkname Ilogb C.ilogb
+func Ilogb(x float64) c.Int
+
+//go:linkname J0 C.j0
+func J0(x float64) float64
+
+//go:linkname J1 C.j1
+func J1(x float64) float64
+
+//go:linkname Jn C.jn
+func Jn(n c.Int, x float64) float64
+
+//go:linkname Ldexp C.ldexp
+func Ldexp(x float64, exp c.Int) float64
+
+//go:linkname Lgamma C.lgamma
+func Lgamma(x float64) float64
+
+//go:linkname Log C.log
+func Log(x float64) float64
+
+//go:linkname Log10 C.log10
+func Log10(x float64) float64
+
+//go:linkname Log1p C.log1p
+func Log1p(x float64) float64
+
+//go:linkname Log2 C.log2
+func Log2(x float64) float64
+
+//go:linkname Logb C.logb
+func Logb(x float64) float64
+
+//go:linkname Modf C.modf
+func Modf(x float64, ipart *float64) float64
+
+//go:linkname Nan C.nan
+func Nan(tag *c.Char) float64
+
+//go:linkname Nextafter C.nextafter
+func Nextafter(x, y float64) float64
+
+//go:linkname Pow C.pow
+func Pow(x, y float64) float64
+
+//go:linkname Remainder C.remainder
+func Remainder(x, y float64) float64
+
+//go:linkname Round C.round
+func Round(x float64) float64
+
+//go:linkname Sin C.sin
+func Sin(x float64) float64
+
+//go:linkname Sinh C.sinh
+func Sinh(x float64) float64
+
+//go:linkname Sqrt C.sqrt
+func Sqrt(x float64) float64
+
+//go:linkname Tan C.tan
+func Tan(x float64) float64
+
+//go:linkname Tanh C.tanh
+func Tanh(x float64) float64
+
+//go:linkname Tgamma C.tgamma
+func Tgamma(x float64) float64
+
+//go:linkname Trunc C.trunc
+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

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rand
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+// -----------------------------------------------------------------------------
+
+//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()
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Random C.random
+func Random() c.Long
+
+//go:linkname Srandom C.srandom
+func Srandom(c.Uint)
+
+//go:linkname Srandomdev C.srandomdev
+func Srandomdev()
+
+// -----------------------------------------------------------------------------

c/os/os.go

@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package os
+
+// #include <sys/stat.h>
+// #include <limits.h>
+import "C"
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/syscall"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+const (
+	PATH_MAX = C.PATH_MAX
+)
+
+type (
+	ModeT C.mode_t
+	UidT  C.uid_t
+	GidT  C.gid_t
+	OffT  C.off_t
+	DevT  C.dev_t
+)
+
+type (
+	StatT = syscall.Stat_t
+)
+
+//go:linkname Errno errno
+var Errno c.Int
+
+//go:linkname Umask C.umask
+func Umask(cmask ModeT) ModeT
+
+//go:linkname Mkdir C.mkdir
+func Mkdir(path *c.Char, mode ModeT) c.Int
+
+//go:linkname Rmdir C.rmdir
+func Rmdir(path *c.Char) c.Int
+
+//go:linkname Link C.link
+func Link(oldpath *c.Char, newpath *c.Char) c.Int
+
+//go:linkname Symlink C.symlink
+func Symlink(target *c.Char, linkpath *c.Char) c.Int
+
+//go:linkname Readlink C.readlink
+func Readlink(path *c.Char, buf c.Pointer, bufsize uintptr) int
+
+//go:linkname Unlink C.unlink
+func Unlink(path *c.Char) c.Int
+
+//go:linkname Remove C.remove
+func Remove(path *c.Char) c.Int
+
+//go:linkname Rename C.rename
+func Rename(oldpath *c.Char, newpath *c.Char) c.Int
+
+//go:linkname Stat C.stat
+func Stat(path *c.Char, buf *StatT) c.Int
+
+//go:linkname Lstat C.lstat
+func Lstat(path *c.Char, buf *StatT) c.Int
+
+//go:linkname Truncate C.truncate
+func Truncate(path *c.Char, length OffT) c.Int
+
+//go:linkname Chmod C.chmod
+func Chmod(path *c.Char, mode ModeT) c.Int
+
+//go:linkname Chown C.chown
+func Chown(path *c.Char, owner UidT, group GidT) c.Int
+
+//go:linkname Lchown C.lchown
+func Lchown(path *c.Char, owner UidT, group GidT) c.Int
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Getcwd C.getcwd
+func Getcwd(buffer c.Pointer, size uintptr) *c.Char
+
+//go:linkname Chdir C.chdir
+func Chdir(path *c.Char) c.Int
+
+//go:linkname Chroot C.chroot
+func Chroot(path *c.Char) c.Int
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Environ environ
+var Environ **c.Char
+
+//go:linkname Getenv C.getenv
+func Getenv(name *c.Char) *c.Char
+
+//go:linkname Setenv C.setenv
+func Setenv(name *c.Char, value *c.Char, overwrite c.Int) c.Int
+
+//go:linkname Putenv C.putenv
+func Putenv(env *c.Char) c.Int
+
+//go:linkname Unsetenv C.unsetenv
+func Unsetenv(name *c.Char) c.Int
+
+//go:linkname Clearenv C.clearenv
+func Clearenv()
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Fchdir C.fchdir
+func Fchdir(dirfd c.Int) c.Int
+
+//go:linkname Faccessat C.faccessat
+func Faccessat(dirfd c.Int, path *c.Char, mode c.Int, flags c.Int) c.Int
+
+//go:linkname Fchmodat C.fchmodat
+func Fchmodat(dirfd c.Int, path *c.Char, mode ModeT, flags c.Int) c.Int
+
+//go:linkname Fchownat C.fchownat
+func Fchownat(dirfd c.Int, path *c.Char, owner UidT, group GidT, flags c.Int) c.Int
+
+//go:linkname Fstatat C.fstatat
+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
+
+//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 Dup C.dup
+func Dup(fd c.Int) c.Int
+
+//go:linkname Dup2 C.dup2
+func Dup2(oldfd c.Int, newfd c.Int) c.Int
+
+/* TODO(xsw):
+On Alpha, IA-64, MIPS, SuperH, and SPARC/SPARC64, pipe() has the following prototype:
+struct fd_pair {
+	long fd[2];
+};
+struct fd_pair pipe(void);
+*/
+//go:linkname Pipe C.pipe
+func Pipe(fds *[2]c.Int) c.Int
+
+//go:linkname Mkfifo C.mkfifo
+func Mkfifo(path *c.Char, mode ModeT) c.Int
+
+//go:linkname Mknod C.mknod
+func Mknod(path *c.Char, mode ModeT, dev DevT) c.Int
+
+//go:linkname Close C.close
+func Close(fd c.Int) c.Int
+
+//go:linkname Read C.read
+func Read(fd c.Int, buf c.Pointer, count uintptr) int
+
+//go:linkname Write C.write
+func Write(fd c.Int, buf c.Pointer, count uintptr) int
+
+//go:linkname Lseek C.lseek
+func Lseek(fd c.Int, offset OffT, whence c.Int) OffT
+
+//go:linkname Fsync C.fsync
+func Fsync(fd c.Int) c.Int
+
+//go:linkname Ftruncate C.ftruncate
+func Ftruncate(fd c.Int, length OffT) c.Int
+
+//go:linkname Fchmod C.fchmod
+func Fchmod(fd c.Int, mode ModeT) c.Int
+
+//go:linkname Fchown C.fchown
+func Fchown(fd c.Int, owner UidT, group GidT) c.Int
+
+//go:linkname Fstat C.fstat
+func Fstat(fd c.Int, buf *StatT) c.Int
+
+//go:linkname Isatty C.isatty
+func Isatty(fd c.Int) 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
+
+//go:linkname Fork C.fork
+func Fork() c.Int
+
+//go:linkname Kill C.kill
+func Kill(pid c.Int, sig c.Int) c.Int
+
+//go:linkname Exit C.exit
+func Exit(c.Int)
+
+//go:linkname Getpid C.getpid
+func Getpid() c.Int
+
+//go:linkname Getppid C.getppid
+func Getppid() c.Int
+
+//go:linkname Getuid C.getuid
+func Getuid() UidT
+
+//go:linkname Geteuid C.geteuid
+func Geteuid() UidT
+
+//go:linkname Getgid C.getgid
+func Getgid() GidT
+
+//go:linkname Getegid C.getegid
+func Getegid() GidT
+
+// -----------------------------------------------------------------------------

c/pthread/sync/_pthd/pthd.c

@@ -0,0 +1,7 @@
+#include <pthread.h>
+
+// -----------------------------------------------------------------------------
+
+pthread_once_t llgoSyncOnceInitVal = PTHREAD_ONCE_INIT;
+
+// -----------------------------------------------------------------------------

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

@@ -0,0 +1,174 @@
+/*
+ * 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 <pthread.h>
+import "C"
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/time"
+)
+
+const (
+	LLGoFiles   = "_pthd/pthd.c"
+	LLGoPackage = "link"
+)
+
+// -----------------------------------------------------------------------------
+
+// Once is an object that will perform exactly one action.
+type Once C.pthread_once_t
+
+//go:linkname OnceInit llgoSyncOnceInitVal
+var OnceInit Once
+
+// llgo:link (*Once).Do C.pthread_once
+func (o *Once) Do(f func()) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+type MutexType c.Int
+
+const (
+	MUTEX_NORMAL     MutexType = C.PTHREAD_MUTEX_NORMAL
+	MUTEX_ERRORCHECK MutexType = C.PTHREAD_MUTEX_ERRORCHECK
+	MUTEX_RECURSIVE  MutexType = C.PTHREAD_MUTEX_RECURSIVE
+	MUTEX_DEFAULT    MutexType = C.PTHREAD_MUTEX_DEFAULT
+)
+
+// MutexAttr is a mutex attribute object.
+type MutexAttr C.pthread_mutexattr_t
+
+// llgo:link (*MutexAttr).Init C.pthread_mutexattr_init
+func (a *MutexAttr) Init(attr *MutexAttr) c.Int { return 0 }
+
+// llgo:link (*MutexAttr).Destroy C.pthread_mutexattr_destroy
+func (a *MutexAttr) Destroy() {}
+
+// llgo:link (*MutexAttr).SetType C.pthread_mutexattr_settype
+func (a *MutexAttr) SetType(typ MutexType) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+// Mutex is a mutual exclusion lock.
+type Mutex C.pthread_mutex_t
+
+// llgo:link (*Mutex).Init C.pthread_mutex_init
+func (m *Mutex) Init(attr *MutexAttr) c.Int { return 0 }
+
+// llgo:link (*Mutex).Destroy C.pthread_mutex_destroy
+func (m *Mutex) Destroy() {}
+
+// llgo:link (*Mutex).Lock C.pthread_mutex_lock
+func (m *Mutex) Lock() {}
+
+// llgo:link (*Mutex).TryLock C.pthread_mutex_trylock
+func (m *Mutex) TryLock() c.Int { return 0 }
+
+// llgo:link (*Mutex).Unlock C.pthread_mutex_unlock
+func (m *Mutex) Unlock() {}
+
+// -----------------------------------------------------------------------------
+
+// RWLockAttr is a read-write lock attribute object.
+type RWLockAttr C.pthread_rwlockattr_t
+
+// llgo:link (*RWLockAttr).Init C.pthread_rwlockattr_init
+func (a *RWLockAttr) Init(attr *RWLockAttr) c.Int { return 0 }
+
+// llgo:link (*RWLockAttr).Destroy C.pthread_rwlockattr_destroy
+func (a *RWLockAttr) Destroy() {}
+
+// llgo:link (*RWLockAttr).SetPShared C.pthread_rwlockattr_setpshared
+func (a *RWLockAttr) SetPShared(pshared c.Int) c.Int { return 0 }
+
+// llgo:link (*RWLockAttr).GetPShared C.pthread_rwlockattr_getpshared
+func (a *RWLockAttr) GetPShared(pshared *c.Int) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+// RWLock is a read-write lock.
+type RWLock C.pthread_rwlock_t
+
+// llgo:link (*RWLock).Init C.pthread_rwlock_init
+func (rw *RWLock) Init(attr *RWLockAttr) c.Int { return 0 }
+
+// llgo:link (*RWLock).Destroy C.pthread_rwlock_destroy
+func (rw *RWLock) Destroy() {}
+
+// llgo:link (*RWLock).RLock C.pthread_rwlock_rdlock
+func (rw *RWLock) RLock() {}
+
+// llgo:link (*RWLock).TryRLock C.pthread_rwlock_tryrdlock
+func (rw *RWLock) TryRLock() c.Int { return 0 }
+
+// llgo:link (*RWLock).RUnlock C.pthread_rwlock_unlock
+func (rw *RWLock) RUnlock() {}
+
+// llgo:link (*RWLock).Lock C.pthread_rwlock_wrlock
+func (rw *RWLock) Lock() {}
+
+// llgo:link (*RWLock).TryLock C.pthread_rwlock_trywrlock
+func (rw *RWLock) TryLock() c.Int { return 0 }
+
+// llgo:link (*RWLock).Unlock C.pthread_rwlock_unlock
+func (rw *RWLock) Unlock() {}
+
+// -----------------------------------------------------------------------------
+
+// CondAttr is a condition variable attribute object.
+type CondAttr C.pthread_condattr_t
+
+// llgo:link (*CondAttr).Init C.pthread_condattr_init
+func (a *CondAttr) Init(attr *CondAttr) c.Int { return 0 }
+
+// llgo:link (*CondAttr).Destroy C.pthread_condattr_destroy
+func (a *CondAttr) Destroy() {}
+
+// llgo:link (*CondAttr).SetClock C.pthread_condattr_setclock
+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.ClockidT) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+
+// Cond is a condition variable.
+type Cond C.pthread_cond_t
+
+// llgo:link (*Cond).Init C.pthread_cond_init
+func (c *Cond) Init(attr *CondAttr) c.Int { return 0 }
+
+// llgo:link (*Cond).Destroy C.pthread_cond_destroy
+func (c *Cond) Destroy() {}
+
+// llgo:link (*Cond).Signal C.pthread_cond_signal
+func (c *Cond) Signal() c.Int { return 0 }
+
+// llgo:link (*Cond).Broadcast C.pthread_cond_broadcast
+func (c *Cond) Broadcast() c.Int { return 0 }
+
+// llgo:link (*Cond).Wait C.pthread_cond_wait
+func (c *Cond) Wait(m *Mutex) c.Int { return 0 }
+
+// llgo:link (*Cond).TimedWait C.pthread_cond_timedwait
+func (c *Cond) TimedWait(m *Mutex, abstime *time.Timespec) 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/sqlite/README.md

@@ -1,22 +1,18 @@
 LLGo wrapper of sqlite
 =====
-[![Build Status](https://github.com/goplus/sqlite/actions/workflows/go.yml/badge.svg)](https://github.com/goplus/sqlite/actions/workflows/go.yml)
-[![GitHub release](https://img.shields.io/github/v/tag/goplus/sqlite.svg?label=release)](https://github.com/goplus/sqlite/releases)
-[![GoDoc](https://pkg.go.dev/badge/github.com/goplus/sqlite.svg)](https://pkg.go.dev/github.com/goplus/sqlite)
-[![Compiler](https://img.shields.io/badge/compiler-llgo-darkgreen.svg)](https://github.com/goplus/llgo)
-[![Language](https://img.shields.io/badge/language-Go+-blue.svg)](https://github.com/goplus/gop)
 
 ## How to install
 
+### on macOS (Homebrew)
+
 ```sh
-git clone https://github.com/goplus/sqlite.git
-cd sqlite
-git submodule init
-git submodule update
-mkdir build.dir
-cd build.dir
-../sqlite/configure --enable-shared
-sudo make install
+brew install sqlite3
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+apt-get install -y libsqlite3-dev
 ```
 
 ## Demos

c/sqlite/_demo/sqlitedemo/demo.go

@@ -2,11 +2,12 @@ package main
 
 import (
 	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/os"
 	"github.com/goplus/llgo/c/sqlite"
 )
 
 func main() {
-	c.Remove(c.Str("test.db"))
+	os.Remove(c.Str("test.db"))
 
 	db, err := sqlite.Open(c.Str("test.db"))
 	check(err, db, "sqlite: Open")