Merge pull request #459 from xushiwei/ll

README: run _pydemo

.github/workflows/go.yml

@@ -11,45 +11,38 @@ on:
 
 jobs:
 
-  test-macos:
-    runs-on: macos-latest
+  test:
     strategy:
       matrix:
-        llvm: [17]
+        os: [macos-latest, ubuntu-latest]
+        llvm: [18]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
 
       - name: Update Homebrew
-        if: matrix.llvm == 17 # needed as long as LLVM 17 is still fresh
+        # 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 }}
-        run: HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }}
-        
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.20'
-
-      - name: Build
-        run: go build -v ./...
-
-      - name: Test
-        run: go test -v ./...
-
-  test-linux:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        llvm: [17]
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Install LLVM ${{ matrix.llvm }}
+      - name: Install LLVM ${{ matrix.llvm }} and bdw-gc
+        if: startsWith(matrix.os, 'macos')
         run: |
-        echo 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{ matrix.llvm }} main' | sudo tee /etc/apt/sources.list.d/llvm.list
+          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@${{ matrix.llvm }} bdw-gc
+          echo `brew --prefix llvm@${{ matrix.llvm }}`/bin >> $GITHUB_PATH
+      - name: Install LLVM ${{ matrix.llvm }} and libgc-dev
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{ matrix.llvm }} main" | sudo tee /etc/apt/sources.list.d/llvm.list
           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 llvm-${{ matrix.llvm }}-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
+        run: |
+          echo $PATH
+          which clang
+          clang --version
         
       - name: Set up Go
         uses: actions/setup-go@v5
@@ -60,8 +53,38 @@ jobs:
         run: go build -v ./...
 
       - name: Test
+        if: matrix.os != 'macos-latest'
+        run: go test -v ./...
+
+      - name: Test with coverage
+        if: matrix.os == 'macos-latest'
         run: go test -v -coverprofile="coverage.txt" -covermode=atomic ./...
 
+      - name: Install
+        run: go install ./...
+      
+      - name: LLGO tests
+        if: matrix.os != 'ubuntu-latest'
+        run: |
+          echo "Test result on ${{ matrix.os }} with LLVM ${{ matrix.llvm }}" > result.md
+          LLGOROOT=$PWD bash .github/workflows/test_llgo.sh
+      
+      - name: Test _demo and _pydemo
+        run: |
+          set +e
+          LLGOROOT=$PWD bash .github/workflows/test_demo.sh
+          exit 0
+      
+      - name: Show test result
+        run: cat result.md
+
+      - name: PR comment with test result
+        uses: thollander/actions-comment-pull-request@v2
+        if: false
+        with:
+          filePath: result.md
+          comment_tag: test-result-on-${{ matrix.os }}-with-llvm-${{ matrix.llvm }}
+
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v4
         with:

.github/workflows/test_demo.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# llgo run subdirectories under _demo and _pydemo
+total=0
+failed=0
+failed_cases=""
+for d in ./_demo/* ./_pydemo/*; do
+  total=$((total+1))
+  if [ -d "$d" ]; then
+    echo "Testing $d"
+    if ! llgo run -v "$d"; then
+      echo "FAIL"
+      failed=$((failed+1))
+      failed_cases="$failed_cases\n* :x: $d"
+    else
+      echo "PASS"
+    fi
+  fi
+done
+echo "=== Done"
+echo "$((total-failed))/$total tests passed"
+
+if [ "$failed" -ne 0 ]; then
+  echo ":bangbang: Failed demo cases:" | tee -a result.md
+  echo -e "$failed_cases" | tee -a result.md
+  exit 1
+else
+  echo ":white_check_mark: All demo tests passed" | tee -a result.md
+fi

.github/workflows/test_llgo.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+set -e
+
+export LLGOROOT=$PWD
+
+testcmd=/tmp/test
+llgo build -o $testcmd ./_test
+cases=$($testcmd)
+total=$(echo "$cases" | wc -l | tr -d ' ')
+failed=0
+failed_cases=""
+
+for idx in $(seq 1 $((total))); do
+  case=$(echo "$cases" | sed -n "${idx}p")
+  case_name=$(echo "$case" | cut -d',' -f2)
+  echo "=== Test case: $case_name"
+  set +e
+  out=$("$testcmd" "$((idx-1))" 2>&1)
+  exit_code=$?
+  set -e
+  if [ "${exit_code:-0}" -ne 0 ]; then
+    echo "failed: $out"
+    failed=$((failed+1))
+    failed_cases="$failed_cases\n* :x: $case_name"
+  else
+    echo "passed"
+  fi
+done
+echo "=== Done"
+echo "$((total-failed))/$total tests passed"
+
+if [ "$failed" -ne 0 ]; then
+  echo ":bangbang: Failed llgo cases:" | tee -a result.md
+  echo -e "$failed_cases" | tee -a result.md
+  exit 1
+else
+  echo ":white_check_mark: All llgo tests passed" | tee -a result.md
+fi

.gitignore

@@ -9,7 +9,8 @@
 *.dylib
 
 test.db
-llgo_autogen.ll
+demo.ll
+llgo_autogen*.ll
 stories*.bin
 .DS_Store
 err.log
@@ -18,6 +19,7 @@ numpy.txt
 _go/
 _runtime/
 _tinygo/
+_output/
 build.dir/
 .vscode/
 

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "x/llama2/llama2.c"]
-	path = x/llama2/llama2.c
+[submodule "c/llama2/llama2.c"]
+	path = c/llama2/llama2.c
 	url = https://github.com/karpathy/llama2.c.git

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,46 +64,59 @@ 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/genints
+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
 
 You can import a Python library in LLGo!
 
-And you can import any Python library into `llgo` through a program called `llpyg`. The currently imported libraries include:
+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`:
 
-* [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)
+* [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:
 
@@ -81,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() {
@@ -98,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)
 }
 ```
 
@@ -111,83 +154,100 @@ 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
 
 LLGo can easily import any libraries from the C ecosystem. Currently, this import process is still manual, but in the future, it will be automated similar to Python library imports.
 
-The currently imported libraries include:
+The currently supported libraries include:
 
-* [llama2.c](https://pkg.go.dev/github.com/goplus/llgo/x/llama2)
-* [cjson](https://pkg.go.dev/github.com/goplus/llgo/x/cjson)
-* [sqlite](https://pkg.go.dev/github.com/goplus/llgo/x/sqlite)
+* [c/bdwgc](https://pkg.go.dev/github.com/goplus/llgo/c/bdwgc)
+* [c/cjson](https://pkg.go.dev/github.com/goplus/llgo/c/cjson)
+* [c/clang](https://pkg.go.dev/github.com/goplus/llgo/c/clang)
+* [c/llama2](https://pkg.go.dev/github.com/goplus/llgo/c/llama2)
+* [c/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](x/cjson/_demo/mkjson/mkjson.go): create a json object and print it
-* [sqlite](x/sqlite/_demo/sqlitedemo/demo.go): a basic sqlite demo
+* [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
 
-The priority of `llgo` feature iteration is:
-
-* Popular C/Python libraries
-* Full Go syntax
-* Go standard libraries
-* Popular Go packages
-
-Common Go syntax is already supported. Except for the following, which needs to be improved:
-
-* interface (Limited support)
-* map (Very limited support)
-* panic (Limited support)
-* recover (Not supported yet)
-* defer (Not supported yet)
-* gc (Not supported yet)
-* chan (Not supported yet)
-* goroutine (Not supported yet)
-* generics (Not supported yet)
-
-Here are some examples related to Go syntax:
+All Go syntax 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](_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.
+
+
+### Garbage Collection (GC)
+
+By default, LLGo implements `gc` based on [bdwgc](https://www.hboehm.info/gc/) (also known as [libgc](https://www.hboehm.info/gc/)).
+
+However, you can disable gc by specifying the `nogc` tag. For example:
+
+```sh
+llgo run -tags nogc .
+```
+
+
+## Go packages support
+
+Here are the Go packages that can be imported correctly:
+
+* [unsafe](https://pkg.go.dev/unsafe)
+* [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):
@@ -196,20 +256,57 @@ Follow these steps to generate the `llgo` command (its usage is the same as the
 
 ```sh
 brew update # execute if needed
-brew install llvm@17
+brew install llvm@18 pkg-config libgc
+brew install cjson sqlite python@3.12 # optional
+export PATH=$(brew --prefix llvm@18)/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.zshrc
+git clone https://github.com/goplus/llgo.git
+cd llgo
+export LLGOROOT="/path/to/llgo" # Replace this with the root directory of the llgo project
 go install -v ./...
 ```
 
-### 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 --no-install-recommends llvm-17-dev
+sudo apt-get install -y llvm-18-dev clang-18 lld-18 pkg-config libgc-dev
+sudo apt-get install -y libcjson-dev libsqlite3-dev python3.12-dev # optional
+export PATH=/usr/lib/llvm-18/bin:$PATH # you may want to add this to your shell RC file, e.g. ~/.bashrc
+git clone https://github.com/goplus/llgo.git
+cd llgo
+export LLGOROOT="/path/to/llgo" # Replace this with the root directory of the llgo project
 go install -v ./...
 ```
 
 ### on Windows
 
 TODO
+
+
+## Development tools
+
+* [pydump](chore/_xtool/pydump): It's the first program compiled by `llgo` (NOT `go`) in a production environment. It outputs symbol information (functions, variables, and constants) from a Python library in JSON format, preparing for the generation of corresponding packages in `llgo`.
+* [pysigfetch](https://github.com/goplus/hdq/tree/main/chore/pysigfetch): It generates symbol information by extracting information from Python's documentation site. This tool is not part of the `llgo` project, but we depend on it.
+* [llpyg](chore/llpyg): It is used to automatically convert Python libraries into Go packages that `llgo` can import. It depends on `pydump` and `pysigfetch` to accomplish the task.
+* [llgen](chore/llgen): It is used to compile Go packages into LLVM IR files (*.ll).
+* [ssadump](chore/ssadump): It is a Go SSA builder and interpreter.
+
+How do I generate these tools?
+
+```sh
+export CC=clang CXX=clang++ # only for go build; optional if you have other compatible compilers
+go install -v ./...  # compile all tools except pydump
+cd chore/_xtool
+llgo install ./...   # compile pydump
+go install github.com/goplus/hdq/chore/pysigfetch@v0.8.1  # compile pysigfetch
+```
+
+## Key modules
+
+Below are the key modules for understanding the implementation principles of `llgo`:
+
+* [llgo/ssa](https://pkg.go.dev/github.com/goplus/llgo/ssa): It generates LLVM IR files (LLVM SSA) using the semantics (interfaces) of Go SSA. Although `LLVM SSA` and `Go SSA` are both IR languages, they work at completely different levels. `LLVM SSA` is closer to machine code, which abstracts different instruction sets. While `Go SSA` is closer to a high-level language. We can think of it as the instruction set of the `Go computer`. `llgo/ssa` is not just limited to the `llgo` compiler. If we view it as the high-level expressive power of `LLVM`, you'll find it very useful. Prior to `llgo/ssa`, you had to operate `LLVM` using machine code semantics. But now, with the advanced SSA form (in the semantics of Go SSA), you can conveniently utilize `LLVM`.
+* [llgo/cl](https://pkg.go.dev/github.com/goplus/llgo/cl): It is the core of the llgo compiler. It converts a Go package into LLVM IR files. It depends on `llgo/ssa`.
+* [llgo/internal/build](https://pkg.go.dev/github.com/goplus/llgo/internal/build): It strings together the entire compilation process of `llgo`. It depends on `llgo/ssa` and `llgo/cl`.

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

@@ -0,0 +1,17 @@
+package main
+
+func f(s string) bool {
+	return len(s) > 2
+}
+
+func main() {
+	defer func() {
+		println("hi")
+	}()
+	if s := "hello"; f(s) {
+		defer println(s)
+	} else {
+		defer println("world")
+	}
+	defer println("bye")
+}

_cmptest/errors/errors.go

@@ -0,0 +1,21 @@
+package main
+
+// New returns an error that formats as the given text.
+// Each call to New returns a distinct error value even if the text is identical.
+func New(text string) error {
+	return &errorString{text}
+}
+
+// errorString is a trivial implementation of error.
+type errorString struct {
+	s string
+}
+
+func (e *errorString) Error() string {
+	return e.s
+}
+
+func main() {
+	err := New("an error")
+	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/foo/foo.go

@@ -0,0 +1,9 @@
+package foo
+
+func Bar() any {
+	return struct{ V int }{1}
+}
+
+func F() any {
+	return struct{ v int }{1}
+}

_cmptest/interf/interf.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"github.com/goplus/llgo/_cmptest/interf/foo"
+)
+
+func Foo() any {
+	return struct{ v int }{1}
+}
+
+func main() {
+	v := Foo()
+	if x, ok := v.(struct{ v int }); ok {
+		println(x.v)
+	} else {
+		println("Foo: not ok")
+	}
+	bar := foo.Bar()
+	if x, ok := bar.(struct{ V int }); ok {
+		println(x.V)
+	} else {
+		println("Bar: not ok")
+	}
+	if x, ok := foo.F().(struct{ v int }); ok {
+		println(x.v)
+	} else {
+		println("F: not ok")
+	}
+}
+
+/* Expected output:
+1
+1
+F: not ok
+*/

_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/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)
+		}
+	}
+}

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

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	done := false
+	go func() {
+		println("Hello, goroutine")
+		done = true
+	}()
+	for !done {
+		print(".")
+	}
+}

_demo/gotime/time.go

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

_demo/llama2-c/run.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/x/llama2"
+	"github.com/goplus/llgo/c/llama2"
 )
 
 func main() {

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

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c/setjmp"
+)
+
+func main() {
+	var jb setjmp.SigjmpBuf
+	switch ret := setjmp.Sigsetjmp(&jb, 0); ret {
+	case 0:
+		println("Hello, setjmp!")
+		setjmp.Siglongjmp(&jb, 1)
+	default:
+		println("exception:", ret)
+	}
+}

_demo/thread/thd.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/pthread"
+)
+
+var key pthread.Key
+
+func main() {
+	key.Create(nil)
+	key.Set(c.Pointer(c.Str("main value\n")))
+
+	var thd pthread.Thread
+	pthread.Create(&thd, nil, func(arg c.Pointer) c.Pointer {
+		key.Set(c.Pointer(c.Str("thread value\n")))
+		c.Printf(c.Str("Hello, thread\nTLS: %s"), key.Get())
+		return c.Pointer(c.Str("Back to main\n"))
+	}, nil)
+
+	var retval c.Pointer
+	pthread.Join(thd, &retval)
+
+	c.Printf(c.Str("%sTLS: %s"), retval, key.Get())
+}

_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)
 }

_pydemo/max/max.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/std"
+)
+
+func main() {
+	x := std.Max(py.Float(3.0), py.Float(9.0), py.Float(23.0), py.Float(100.0))
+	std.Print(x)
+
+	list := py.List(3.0, 9.0, 23.0, 100.0)
+	y := std.Max(std.Iter(list))
+	std.Print(y)
+}

_pydemo/print/print.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/std"
+)
+
+func main() {
+	x := py.Float(3.14)
+	std.Print(x)
+}

_pydemo/tensor/tensor.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"github.com/goplus/llgo/py"
+	"github.com/goplus/llgo/py/std"
+	"github.com/goplus/llgo/py/torch"
+)
+
+func main() {
+	data := py.List(
+		py.List(1.0, 2.0),
+		py.List(3.0, 4.0),
+	)
+	x := torch.Tensor(data)
+	std.Print(x)
+}

_test/bdwgc.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/_test/testing"
+	"github.com/goplus/llgo/c"
+	"github.com/goplus/llgo/c/bdwgc"
+)
+
+// ------ Test malloc ------
+
+func TestMalloc(t *testing.T) {
+	pn := (*int)(bdwgc.Malloc(unsafe.Sizeof(int(0))))
+	*pn = 1 << 30
+	c.Printf(c.Str("value: %d, %x, %p, %p\n"), *pn, *pn, pn, &pn)
+
+	pl := (*int64)(bdwgc.Realloc(c.Pointer(pn), unsafe.Sizeof(int64(0))))
+	*pl = 1 << 60
+	c.Printf(c.Str("value: %lld, %llx, %p, %p\n"), *pl, *pl, pl, &pl)
+
+	bdwgc.Free(c.Pointer(pl))
+}
+
+// ------ Test finalizer ------
+
+const (
+	RETURN_VALUE_FREED = 1 << 31
+)
+
+var called uint = 0
+
+func setReturnValueFreed(pobj c.Pointer, clientData c.Pointer) {
+	called |= RETURN_VALUE_FREED
+	c.Printf(c.Str("called: %x\n"), called)
+}
+
+func setLoopValueFreed(pobj c.Pointer, clientData c.Pointer) {
+	pmask := (*uint)(clientData)
+	called |= *pmask
+	c.Printf(c.Str("called: %x\n"), called)
+}
+
+func isCalled(mask uint) bool {
+	return called&mask != 0
+}
+
+func returnValue() *int {
+	pn := bdwgc.Malloc(unsafe.Sizeof(int(0)))
+	bdwgc.RegisterFinalizer(pn, setReturnValueFreed, nil, nil, nil)
+	return (*int)(pn)
+}
+
+func callFunc() {
+	pn := returnValue()
+	*pn = 1 << 30
+	c.Printf(c.Str("value: %d, %x, %p, %p\n"), *pn, *pn, pn, &pn)
+	bdwgc.Gcollect()
+	check(!isCalled(RETURN_VALUE_FREED), c.Str("finalizer should not be called"))
+}
+
+func loop() {
+	for i := 0; i < 5; i++ {
+		p := bdwgc.Malloc(unsafe.Sizeof(int(0)))
+		pn := (*int)(p)
+		*pn = i
+		c.Printf(c.Str("value: %d, %x, %p, %p\n"), *pn, *pn, pn, &pn)
+		pflag := (*uint)(c.Malloc(unsafe.Sizeof(uint(0))))
+		*pflag = 1 << i
+		bdwgc.RegisterFinalizer(p, setLoopValueFreed, c.Pointer(pflag), nil, nil)
+		bdwgc.Gcollect()
+		check(!isCalled(1<<i), c.Str("finalizer should not be called"))
+		for j := 0; j < i; j++ {
+			check(isCalled(1<<j), c.Str("finalizers of previous objects should be called"))
+		}
+	}
+}
+
+// Clear stack to avoid reference
+func clearStack() {
+	p := c.Alloca(128)
+	c.Memset(p, 0, 128)
+}
+
+func check(b bool, msg *c.Char) {
+	if !b {
+		c.Printf(c.Str("check failed: %s\n"), msg)
+		panic("check failed")
+	}
+}
+
+func TestFinalizer(t *testing.T) {
+	bdwgc.Init()
+
+	callFunc()
+	clearStack()
+	bdwgc.Gcollect()
+	check(isCalled(RETURN_VALUE_FREED), c.Str("finalizer should be called"))
+
+	loop()
+}

_test/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"github.com/goplus/llgo/_test/testing"
+	"github.com/goplus/llgo/c"
+)
+
+type TestCase struct {
+	Name string
+	F    func(*testing.T)
+}
+
+func main() {
+	tests := []TestCase{
+		{"TestMalloc", TestMalloc},
+		{"TestFinalizer", TestFinalizer},
+	}
+	if c.Argc == 1 {
+		for _, test := range tests {
+			c.Printf(c.Str("%s\n"), c.AllocaCStr(test.Name))
+		}
+		return
+	}
+	c.Fprintf(c.Stderr, c.Str("arg: %s\n"), c.Index(c.Argv, 1))
+	idx := int(c.Atoi(c.Index(c.Argv, 1)))
+	if idx < 0 || idx >= len(tests) {
+		c.Printf(c.Str("invalid test index %d"), idx)
+		panic("invalid test index")
+	}
+	tests[idx].F(nil)
+}

_test/testing/testing.go

@@ -0,0 +1,4 @@
+package testing
+
+type T struct {
+}

c/bdwgc/bdwgc.go

@@ -0,0 +1,103 @@
+/*
+ * 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 bdwgc
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "link: $(pkg-config --libs bdw-gc); -lgc"
+)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Init C.GC_init
+func Init()
+
+//go:linkname Malloc C.GC_malloc
+func Malloc(size uintptr) c.Pointer
+
+//go:linkname Realloc C.GC_realloc
+func Realloc(ptr c.Pointer, size uintptr) c.Pointer
+
+//go:linkname Free C.GC_free
+func Free(ptr c.Pointer)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname RegisterFinalizer C.GC_register_finalizer
+func RegisterFinalizer(
+	obj c.Pointer,
+	fn func(c.Pointer, c.Pointer), cd c.Pointer,
+	oldFn *func(c.Pointer, c.Pointer), oldCd *c.Pointer)
+
+//go:linkname RegisterFinalizerNoOrder C.GC_register_finalizer_no_order
+func RegisterFinalizerNoOrder(
+	obj c.Pointer,
+	fn func(c.Pointer, c.Pointer), cd c.Pointer,
+	oldFn *func(c.Pointer, c.Pointer), oldCd *c.Pointer)
+
+//go:linkname RegisterFinalizerIgnoreSelf C.GC_register_finalizer_ignore_self
+func RegisterFinalizerIgnoreSelf(
+	obj c.Pointer,
+	fn func(c.Pointer, c.Pointer), cd c.Pointer,
+	oldFn *func(c.Pointer, c.Pointer), oldCd *c.Pointer)
+
+//go:linkname RegisterFinalizerUnreachable C.GC_register_finalizer_unreachable
+func RegisterFinalizerUnreachable(
+	obj c.Pointer,
+	fn func(c.Pointer, c.Pointer), cd c.Pointer,
+	oldFn *func(c.Pointer, c.Pointer), oldCd *c.Pointer)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Enable C.GC_enable
+func Enable()
+
+//go:linkname Disable C.GC_disable
+func Disable()
+
+//go:linkname IsDisabled C.GC_is_disabled
+func IsDisabled() c.Int
+
+//go:linkname Gcollect C.GC_gcollect
+func Gcollect()
+
+//go:linkname GetMemoryUse C.GC_get_memory_use
+func GetMemoryUse() uintptr
+
+// -----------------------------------------------------------------------------
+
+//go:linkname EnableIncremental C.GC_enable_incremental
+func EnableIncremental()
+
+//go:linkname IsIncrementalMode C.GC_is_incremental_mode
+func IsIncrementalMode() c.Int
+
+//go:linkname IncrementalProtectionNeeds C.GC_incremental_protection_needs
+func IncrementalProtectionNeeds() c.Int
+
+//go:linkname StartIncrementalCollection C.GC_start_incremental_collection
+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"
 
@@ -26,17 +29,23 @@ 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
 )
 
+type (
+	Int  C.int
+	Uint C.uint
+
+	Long  C.long
+	Ulong C.ulong
+
+	LongLong  C.longlong
+	UlongLong C.ulonglong
+)
+
 type integer interface {
 	~int | ~uint | ~uintptr | ~int32 | ~uint32 | ~int64 | ~uint64
 }
@@ -44,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 }
@@ -56,27 +68,111 @@ func Alloca(size uintptr) Pointer
 //go:linkname AllocaCStr llgo.allocaCStr
 func AllocaCStr(s string) *Char
 
-//go:linkname Unreachable llgo.unreachable
-func Unreachable()
+// TODO(xsw):
+// llgo:link AllocaNew llgo.allocaNew
+func AllocaNew[T any]() *T { return nil }
 
 //go:linkname Malloc C.malloc
 func Malloc(size uintptr) Pointer
 
+//go:linkname Free C.free
+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 Remove C.remove
-func Remove(path *Char) Int
+//go:linkname AllocaSigjmpBuf llgo.sigjmpbuf
+func AllocaSigjmpBuf() Pointer
+
+//go:linkname Sigsetjmp llgo.sigsetjmp
+func Sigsetjmp(jb Pointer, savemask Int) Int
+
+//go:linkname Siglongjmp llgo.siglongjmp
+func Siglongjmp(jb Pointer, retval Int)
+
+//go:linkname Unreachable llgo.unreachable
+func Unreachable()
 
 // -----------------------------------------------------------------------------
 
@@ -93,14 +189,10 @@ func Qsort(base Pointer, count, elem uintptr, compar func(a, b Pointer) Int)
 
 // -----------------------------------------------------------------------------
 
-//go:linkname Stdin __stdinp
-var Stdin FilePtr
+//go:linkname Atoi C.atoi
+func Atoi(s *Char) Int
 
-//go:linkname Stdout __stdoutp
-var Stdout FilePtr
-
-//go:linkname Stderr __stderrp
-var Stderr FilePtr
+// -----------------------------------------------------------------------------
 
 //go:linkname Printf C.printf
 func Printf(format *Char, __llgo_va_list ...any) Int
@@ -108,11 +200,26 @@ func Printf(format *Char, __llgo_va_list ...any) Int
 //go:linkname Fprintf C.fprintf
 func Fprintf(fp FilePtr, format *Char, __llgo_va_list ...any) Int
 
+//go:linkname Fwrite C.fwrite
+func Fwrite(data Pointer, size, count uintptr, fp FilePtr) uintptr
+
+//go:linkname Fputc C.fputc
+func Fputc(c Int, fp FilePtr) Int
+
+//go:linkname Fputs C.fputs
+func Fputs(s *Char, fp FilePtr) Int
+
+//go:linkname Fflush C.fflush
+func Fflush(fp FilePtr) Int
+
 // -----------------------------------------------------------------------------
 
 //go:linkname Time C.time
 func Time(*int32) int32
 
+//go:linkname Usleep C.usleep
+func Usleep(useconds Uint) Int
+
 // -----------------------------------------------------------------------------
 
 type Option struct {

c/c_default.go

@@ -0,0 +1,31 @@
+//go:build !linux
+// +build !linux
+
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package c
+
+import _ "unsafe"
+
+//go:linkname Stdin __stdinp
+var Stdin FilePtr
+
+//go:linkname Stdout __stdoutp
+var Stdout FilePtr
+
+//go:linkname Stderr __stderrp
+var Stderr FilePtr

c/c_linux.go

@@ -0,0 +1,31 @@
+//go:build linux
+// +build linux
+
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package c
+
+import _ "unsafe"
+
+//go:linkname Stdin stdin
+var Stdin FilePtr
+
+//go:linkname Stdout stdout
+var Stdout FilePtr
+
+//go:linkname Stderr stderr
+var Stderr FilePtr

c/cjson/README.md

@@ -0,0 +1,31 @@
+LLGo wrapper of DaveGamble/cJSON
+=====
+
+## How to install
+
+### on macOS (Homebrew)
+
+```sh
+brew install cjson 
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+apt-get install -y libcjson-dev
+```
+
+## Demos
+
+The `_demo` directory contains our demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [mkjson](_demo/mkjson/mkjson.go): create a json object and print it
+
+### How to run demos
+
+To run the demos in directory `_demo`:
+
+```sh
+cd <demo-directory>  # eg. cd _demo/mkjson
+llgo run .
+```

c/cjson/_demo/mkjson/mkjson.go

@@ -2,7 +2,7 @@ package main
 
 import (
 	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/x/cjson"
+	"github.com/goplus/llgo/c/cjson"
 )
 
 func main() {

c/cjson/cjson.go

@@ -23,7 +23,7 @@ import (
 )
 
 const (
-	LLGoPackage = "link: cjson"
+	LLGoPackage = "link: $(pkg-config --libs libcjson); -lcjson"
 )
 
 // llgo:type C
@@ -96,6 +96,11 @@ func (o *JSON) SetItem(key *c.Char, item *JSON) c.Int { return 0 }
 // llgo:link (*JSON).CStr C.cJSON_PrintUnformatted
 func (o *JSON) CStr() *c.Char { return nil }
 
+// Same as CStr. Provided for Go+.
+//
+// llgo:link (*JSON).Cstr C.cJSON_PrintUnformatted
+func (o *JSON) Cstr() *c.Char { return nil }
+
 // Render a JSON entity to text for transfer/storage.
 //
 // llgo:link (*JSON).Print C.cJSON_Print

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

@@ -0,0 +1,160 @@
+/*
+ * 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 llama2
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoFiles   = "llama2/llama2.c"
+	LLGoPackage = "link: -lm"
+)
+
+// -----------------------------------------------------------------------------
+
+// llgo:type C
+type TokenIndex struct {
+	Str *c.Char
+	Id  c.Int
+}
+
+// llgo:type C
+type Tokenizer struct {
+	Vocab          **c.Char
+	VocabScores    *c.Float
+	SortedVocab    *TokenIndex
+	VocabSize      c.Int
+	MaxTokenLength c.Uint
+	BytePieces     [512]uint8 // stores all single-byte strings
+}
+
+//go:linkname BuildTokenizer C.build_tokenizer
+func BuildTokenizer(t *Tokenizer, tokenizerPath *c.Char, vocabSize c.Int)
+
+//go:linkname FreeTokenizer C.free_tokenizer
+func FreeTokenizer(t *Tokenizer)
+
+// -----------------------------------------------------------------------------
+
+// llgo:type C
+type Config struct {
+	Dim       c.Int // transformer dimension
+	HiddenDim c.Int // for ffn layers
+	NLayers   c.Int // number of layers
+	NHeads    c.Int // number of query heads
+	NKVHeads  c.Int // number of key/value heads (can be < query heads because of multiquery)
+	VocabSize c.Int // vocabulary size, usually 256 (byte-level)
+	SeqLen    c.Int // max sequence length
+}
+
+// llgo:type C
+type TransformerWeights struct {
+	// token embedding table
+	TokenEmbeddingTable *c.Float // (vocab_size, dim)
+	// weights for rmsnorms
+	RmsAttWeight *c.Float // (layer, dim) rmsnorm weights
+	RmsFfnWeight *c.Float // (layer, dim)
+	// weights for matmuls. note dim == n_heads * head_size
+	Wq *c.Float // (layer, dim, n_heads * head_size)
+	Wk *c.Float // (layer, dim, n_kv_heads * head_size)
+	Wv *c.Float // (layer, dim, n_kv_heads * head_size)
+	Wo *c.Float // (layer, n_heads * head_size, dim)
+	// weights for ffn
+	W1 *c.Float // (layer, hidden_dim, dim)
+	W2 *c.Float // (layer, dim, hidden_dim)
+	W3 *c.Float // (layer, hidden_dim, dim)
+	// final rmsnorm
+	RmsFinalWeight *c.Float // (dim,)
+	// (optional) classifier weights for the logits, on the last layer
+	Wcls *c.Float
+}
+
+// llgo:type C
+type RunState struct {
+	// current wave of activations
+	X      *c.Float // activation at current time stamp (dim,)
+	Xb     *c.Float // same, but inside a residual branch (dim,)
+	Xb2    *c.Float // an additional buffer just for convenience (dim,)
+	Hb     *c.Float // buffer for hidden dimension in the ffn (hidden_dim,)
+	Hb2    *c.Float // buffer for hidden dimension in the ffn (hidden_dim,)
+	Q      *c.Float // query (dim,)
+	K      *c.Float // key (dim,)
+	V      *c.Float // value (dim,)
+	Att    *c.Float // buffer for scores/attention values (n_heads, seq_len)
+	Logits *c.Float // output logits
+	// kv cache
+	KeyCache   *c.Float // (layer, seq_len, dim)
+	ValueCache *c.Float // (layer, seq_len, dim)
+}
+
+// llgo:type C
+type Transformer struct {
+	Config  Config             // the hyperparameters of the architecture (the blueprint)
+	Weights TransformerWeights // the weights of the model
+	State   RunState           // buffers for the "wave" of activations in the forward pass
+
+	// some more state needed to properly clean up the memory mapping (sigh)
+	Fd       c.Int    // file descriptor for memory mapping
+	Data     *c.Float // memory mapped data pointer
+	FileSize uintptr  // size of the checkpoint file in bytes
+}
+
+//go:linkname BuildTransformer C.build_transformer
+func BuildTransformer(t *Transformer, checkpointPath *c.Char)
+
+//go:linkname FreeTransformer C.free_transformer
+func FreeTransformer(t *Transformer)
+
+// -----------------------------------------------------------------------------
+
+// llgo:type C
+type ProbIndex struct {
+	Prob  c.Float
+	Index c.Int
+} // struct used when sorting probabilities during top-p sampling
+
+// llgo:type C
+type Sampler struct {
+	VocabSize   c.Int
+	Probindex   *ProbIndex // buffer used in top-p sampling
+	Temperature c.Float
+	Topp        c.Float
+	RngState    uint64
+}
+
+//go:linkname BuildSampler C.build_sampler
+func BuildSampler(sampler *Sampler, vocabSize c.Int, temperature c.Float, topp c.Float, rngSeed uint64)
+
+//go:linkname FreeSampler C.free_sampler
+func FreeSampler(sampler *Sampler)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Generate C.generate
+func Generate(
+	transformer *Transformer, tokenizer *Tokenizer, sampler *Sampler,
+	prompt *c.Char, steps c.Int)
+
+//go:linkname Chat C.chat
+func Chat(
+	transformer *Transformer, tokenizer *Tokenizer, sampler *Sampler,
+	cliUserPrompt *c.Char, cliSystemPrompt *c.Char, steps c.Int)
+
+// -----------------------------------------------------------------------------

c/llama2/llama2/llama2.c

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

c/llama2/llama2/run.c

@@ -0,0 +1,973 @@
+/* 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/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,231 @@
+/*
+ * 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"
+)
+
+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
+	StatT C.struct_stat
+)
+
+//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 C.environ
+func 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
+
+// -----------------------------------------------------------------------------
+
+//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/pthread.go

@@ -0,0 +1,160 @@
+/*
+ * 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 pthread
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+func __noop__() c.Int {
+	return 0
+}
+
+// -----------------------------------------------------------------------------
+
+type aThread struct {
+	Unused [8]byte
+}
+
+// Thread represents a POSIX thread.
+type Thread = *aThread
+
+// The pthread_create() function starts a new thread in the calling
+// process.  The new thread starts execution by invoking
+// start_routine(); arg is passed as the sole argument of
+// start_routine().
+//
+// The new thread terminates in one of the following ways:
+//
+//   - It calls pthread_exit(3), specifying an exit status value that
+//     is available to another thread in the same process that calls
+//     pthread_join(3).
+//
+//   - It returns from start_routine().  This is equivalent to
+//     calling pthread_exit(3) with the value supplied in the return
+//     statement.
+//
+//   - It is canceled (see pthread_cancel(3)).
+//
+//   - Any of the threads in the process calls exit(3), or the main
+//     thread performs a return from main().  This causes the
+//     termination of all threads in the process.
+//
+// On success, pthread_create() returns 0; on error, it returns an
+// error number, and the contents of *thread are undefined.
+//
+// See https://man7.org/linux/man-pages/man3/pthread_create.3.html
+//
+//go:linkname Create C.pthread_create
+func Create(pthread *Thread, attr *Attr, routine func(c.Pointer) c.Pointer, arg c.Pointer) c.Int
+
+// The pthread_join() function waits for the thread specified by
+// thread to terminate.  If that thread has already terminated, then
+// pthread_join() returns immediately.  The thread specified by
+// thread must be joinable.
+//
+// If retval is not NULL, then pthread_join() copies the exit status
+// of the target thread (i.e., the value that the target thread
+// supplied to pthread_exit(3)) into the location pointed to by
+// retval.  If the target thread was canceled, then PTHREAD_CANCELED
+// is placed in the location pointed to by retval.
+//
+// If multiple threads simultaneously try to join with the same
+// thread, the results are undefined.  If the thread calling
+// pthread_join() is canceled, then the target thread will remain
+// joinable (i.e., it will not be detached).
+//
+// See https://man7.org/linux/man-pages/man3/pthread_join.3.html
+//
+//go:linkname Join C.pthread_join
+func Join(thread Thread, retval *c.Pointer) c.Int
+
+// The pthread_exit() function terminates the calling thread and
+// returns a value via retval that (if the thread is joinable) is
+// available to another thread in the same process that calls
+// pthread_join(3).
+//
+// See https://man7.org/linux/man-pages/man3/pthread_exit.3.html
+//
+//go:linkname Exit C.pthread_exit
+func Exit(retval c.Pointer)
+
+// The pthread_cancel() function sends a cancelation request to the
+// thread thread.
+//
+// See https://man7.org/linux/man-pages/man3/pthread_cancel.3.html
+//
+//go:linkname Cancel C.pthread_cancel
+func Cancel(thread Thread) c.Int
+
+// -----------------------------------------------------------------------------
+
+// Attr represents a POSIX thread attributes.
+type Attr struct {
+	Detached byte
+	SsSp     *c.Char
+	SsSize   uintptr
+}
+
+// llgo:link (*Attr).Init C.pthread_attr_init
+func (attr *Attr) Init() c.Int { return 0 }
+
+// llgo:link (*Attr).Destroy C.pthread_attr_destroy
+func (attr *Attr) Destroy() c.Int { return 0 }
+
+// llgo:link (*Attr).GetDetached C.pthread_attr_getdetachstate
+func (attr *Attr) GetDetached(detached *c.Int) c.Int { return 0 }
+
+// llgo:link (*Attr).SetDetached C.pthread_attr_setdetachstate
+func (attr *Attr) SetDetached(detached c.Int) c.Int { return 0 }
+
+// llgo:link (*Attr).GetStackSize C.pthread_attr_getstacksize
+func (attr *Attr) GetStackSize(stackSize *uintptr) c.Int { return 0 }
+
+// llgo:link (*Attr).SetStackSize C.pthread_attr_setstacksize
+func (attr *Attr) SetStackSize(stackSize uintptr) c.Int { return 0 }
+
+// llgo:link (*Attr).GetStackAddr C.pthread_attr_getstackaddr
+func (attr *Attr) GetStackAddr(stackAddr *c.Pointer) c.Int { return 0 }
+
+// llgo:link (*Attr).SetStackAddr C.pthread_attr_setstackaddr
+func (attr *Attr) SetStackAddr(stackAddr c.Pointer) c.Int { return 0 }
+
+// -----------------------------------------------------------------------------
+// Thread Local Storage
+
+type Key c.Uint
+
+// llgo:link (*Key).Create C.pthread_key_create
+func (key *Key) Create(destructor func(c.Pointer)) c.Int { return 0 }
+
+// llgo:link Key.Delete C.pthread_key_delete
+func (key Key) Delete() c.Int { return 0 }
+
+// llgo:link Key.Get C.pthread_getspecific
+func (key Key) Get() c.Pointer { return nil }
+
+// llgo:link Key.Set C.pthread_setspecific
+func (key Key) Set(value c.Pointer) c.Int { return __noop__() }
+
+// -----------------------------------------------------------------------------

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

@@ -0,0 +1,53 @@
+/*
+ * 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 setjmp
+
+// #include <setjmp.h>
+import "C"
+
+import (
+	_ "unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+const (
+	LLGoPackage = "decl"
+)
+
+type (
+	JmpBuf    = C.jmp_buf
+	SigjmpBuf = C.sigjmp_buf
+)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Setjmp C.setjmp
+func Setjmp(env *JmpBuf) c.Int
+
+//go:linkname Longjmp C.longjmp
+func Longjmp(env *JmpBuf, val c.Int)
+
+// -----------------------------------------------------------------------------
+
+//go:linkname Sigsetjmp C.sigsetjmp
+func Sigsetjmp(env *SigjmpBuf, savemask c.Int) c.Int
+
+//go:linkname Siglongjmp C.siglongjmp
+func Siglongjmp(env *SigjmpBuf, val c.Int)
+
+// -----------------------------------------------------------------------------

c/setjmp/trycatch/_code/demo.cpp

@@ -0,0 +1,5 @@
+#include <stdexcept>
+
+extern "C" void throwCppException() {
+    throw std::runtime_error("C++ exception");
+}

c/setjmp/trycatch/_code/try_catch.cpp

@@ -0,0 +1,13 @@
+#include <exception>
+#include <stdio.h>
+
+extern "C" void throwCppException();
+
+int main() {
+    try {
+        throwCppException();
+    } catch (std::exception& e) {
+        printf("Hi, %s\n", e.what());
+    }
+    return 0;
+}

c/setjmp/trycatch/demo.go

@@ -0,0 +1,28 @@
+/*
+ * 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 trycatch
+
+import (
+	_ "unsafe"
+)
+
+const (
+	LLGoPackage = "link: c++"
+)
+
+//go:linkname ThrowCppException C.throwCppException
+func ThrowCppException()

c/setjmp/trycatch/llgo.cfg

@@ -0,0 +1,8 @@
+{
+    "cl": [
+        "clang -emit-llvm -S -o demo.ll -c _code/demo.cpp",
+        "clang -emit-llvm -S -o _code/llgo_autogen.ll -c _code/try_catch.cpp",
+        "llgen .",
+        "rm llgo_autogen.lla; zip llgo_autogen.lla llgo_autogen.ll demo.ll",
+    ]
+}

c/sqlite/README.md

@@ -0,0 +1,31 @@
+LLGo wrapper of sqlite
+=====
+
+## How to install
+
+### on macOS (Homebrew)
+
+```sh
+brew install sqlite3
+```
+
+### on Linux (Debian/Ubuntu)
+
+```sh
+apt-get install -y libsqlite3-dev
+```
+
+## Demos
+
+The `_demo` directory contains our demos (it start with `_` to prevent the `go` command from compiling it):
+
+* [sqlitedemo](_demo/sqlitedemo/demo.go): a basic sqlite demo
+
+### How to run demos
+
+To run the demos in directory `_demo`:
+
+```sh
+cd <demo-directory>  # eg. cd _demo/sqlitedemo
+llgo run .
+```

c/sqlite/_demo/sqlitedemo/demo.go

@@ -2,11 +2,12 @@ package main
 
 import (
 	"github.com/goplus/llgo/c"
-	"github.com/goplus/llgo/x/sqlite"
+	"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")

c/sqlite/sqlite.go

@@ -22,14 +22,8 @@ import (
 	"github.com/goplus/llgo/c"
 )
 
-type (
-	Char    = c.Char
-	Int     = c.Int
-	Pointer = c.Pointer
-)
-
 const (
-	LLGoPackage = "link: sqlite3"
+	LLGoPackage = "link: $(pkg-config --libs sqlite3); -lsqlite3"
 )
 
 // llgo:type C
@@ -44,7 +38,7 @@ type Stmt struct {
 
 // -----------------------------------------------------------------------------
 
-type Errno Int
+type Errno c.Int
 
 const (
 	OK Errno = 0 // Successful result
@@ -82,11 +76,11 @@ const (
 	Done   Errno = 101 // sqlite3_step() has finished executing
 )
 
-// llgo:link (Errno).Errstr C.sqlite3_errstr
-func (err Errno) Errstr() *Char { return nil }
+// llgo:link Errno.Errstr C.sqlite3_errstr
+func (err Errno) Errstr() *c.Char { return nil }
 
 // llgo:link (*Sqlite3).Errmsg C.sqlite3_errmsg
-func (db *Sqlite3) Errmsg() *Char { return nil }
+func (db *Sqlite3) Errmsg() *c.Char { return nil }
 
 // llgo:link (*Sqlite3).Errcode C.sqlite3_errcode
 func (db *Sqlite3) Errcode() Errno { return 0 }
@@ -97,13 +91,13 @@ func (db *Sqlite3) ExtendedErrcode() Errno { return 0 }
 // -----------------------------------------------------------------------------
 
 //go:linkname doOpen C.sqlite3_open
-func doOpen(filename *Char, ppDb **Sqlite3) Errno
+func doOpen(filename *c.Char, ppDb **Sqlite3) Errno
 
 //go:linkname doOpenV2 C.sqlite3_open_v2
-func doOpenV2(filename *Char, ppDb **Sqlite3, flags OpenFlags, zVfs *Char) Errno
+func doOpenV2(filename *c.Char, ppDb **Sqlite3, flags OpenFlags, zVfs *c.Char) Errno
 
 // OpenFlags represents SQLite open flags.
-type OpenFlags Int
+type OpenFlags c.Int
 
 const (
 	OpenReadOnly      OpenFlags = 0x00000001
@@ -132,7 +126,7 @@ const (
 
 // Opening A New Database Connection
 // filename: Database filename (UTF-8)
-func Open(filename *Char) (db *Sqlite3, err Errno) {
+func Open(filename *c.Char) (db *Sqlite3, err Errno) {
 	err = doOpen(filename, &db)
 	return
 }
@@ -140,7 +134,7 @@ func Open(filename *Char) (db *Sqlite3, err Errno) {
 // Opening A New Database Connection
 // filename: Database filename (UTF-8)
 // zVfs: Name of VFS module to use
-func OpenV2(filename *Char, flags OpenFlags, zVfs *Char) (db *Sqlite3, err Errno) {
+func OpenV2(filename *c.Char, flags OpenFlags, zVfs *c.Char) (db *Sqlite3, err Errno) {
 	err = doOpenV2(filename, &db, flags, zVfs)
 	return
 }
@@ -158,22 +152,22 @@ func (db *Sqlite3) CloseV2() Errno { return 0 }
 // -----------------------------------------------------------------------------
 
 // llgo:link (*Sqlite3).doPrepare C.sqlite3_prepare
-func (*Sqlite3) doPrepare(*Char, Int, **Stmt, **Char) Errno {
+func (*Sqlite3) doPrepare(*c.Char, c.Int, **Stmt, **c.Char) Errno {
 	return 0
 }
 
 // llgo:link (*Sqlite3).doPrepareV2 C.sqlite3_prepare_v2
-func (*Sqlite3) doPrepareV2(*Char, Int, **Stmt, **Char) Errno {
+func (*Sqlite3) doPrepareV2(*c.Char, c.Int, **Stmt, **c.Char) Errno {
 	return 0
 }
 
 // llgo:link (*Sqlite3).doPrepareV3 C.sqlite3_prepare_v3
-func (*Sqlite3) doPrepareV3(*Char, Int, PrepareFlags, **Stmt, **Char) Errno {
+func (*Sqlite3) doPrepareV3(*c.Char, c.Int, PrepareFlags, **Stmt, **c.Char) Errno {
 	return 0
 }
 
 // PrepareFlags represents SQLite prepare flags.
-type PrepareFlags Int
+type PrepareFlags c.Int
 
 const (
 	PreparePersistent PrepareFlags = 0x01
@@ -183,17 +177,17 @@ const (
 
 // Compiling An SQL Statement
 // tail: Pointer to unused portion of sql
-func (db *Sqlite3) Prepare(sql string, tail **Char) (stmt *Stmt, err Errno) {
+func (db *Sqlite3) Prepare(sql string, tail **c.Char) (stmt *Stmt, err Errno) {
 	err = db.doPrepare(c.GoStringData(sql), c.Int(len(sql)), &stmt, tail)
 	return
 }
 
-func (db *Sqlite3) PrepareV2(sql string, tail **Char) (stmt *Stmt, err Errno) {
+func (db *Sqlite3) PrepareV2(sql string, tail **c.Char) (stmt *Stmt, err Errno) {
 	err = db.doPrepareV2(c.GoStringData(sql), c.Int(len(sql)), &stmt, tail)
 	return
 }
 
-func (db *Sqlite3) PrepareV3(sql string, flags PrepareFlags, tail **Char) (stmt *Stmt, err Errno) {
+func (db *Sqlite3) PrepareV3(sql string, flags PrepareFlags, tail **c.Char) (stmt *Stmt, err Errno) {
 	err = db.doPrepareV3(c.GoStringData(sql), c.Int(len(sql)), flags, &stmt, tail)
 	return
 }
@@ -206,10 +200,10 @@ func (stmt *Stmt) Close() Errno { return 0 }
 // -----------------------------------------------------------------------------
 
 // llgo:link (*Stmt).BindInt C.sqlite3_bind_int
-func (*Stmt) BindInt(idx Int, val Int) Errno { return 0 }
+func (*Stmt) BindInt(idx c.Int, val c.Int) Errno { return 0 }
 
 // llgo:link (*Stmt).BindInt64 C.sqlite3_bind_int64
-func (*Stmt) BindInt64(idx Int, val int64) Errno { return 0 }
+func (*Stmt) BindInt64(idx c.Int, val int64) Errno { return 0 }
 
 /*
 const (
@@ -219,7 +213,9 @@ const (
 */
 
 // llgo:link (*Stmt).BindText C.sqlite3_bind_text
-func (*Stmt) BindText(idx Int, val *Char, nByte Int, destructor func(Pointer)) Errno { return 0 }
+func (*Stmt) BindText(idx c.Int, val *c.Char, nByte c.Int, destructor func(c.Pointer)) Errno {
+	return 0
+}
 
 // -----------------------------------------------------------------------------
 
@@ -238,19 +234,19 @@ func (*Stmt) Step() Errno { return 0 }
 // -----------------------------------------------------------------------------
 
 // llgo:link (*Stmt).ColumnCount C.sqlite3_column_count
-func (stmt *Stmt) ColumnCount() Int { return 0 }
+func (stmt *Stmt) ColumnCount() c.Int { return 0 }
 
 // llgo:link (*Stmt).ColumnName C.sqlite3_column_name
-func (stmt *Stmt) ColumnName(idx Int) *Char { return nil }
+func (stmt *Stmt) ColumnName(idx c.Int) *c.Char { return nil }
 
 // llgo:link (*Stmt).ColumnInt C.sqlite3_column_int
-func (stmt *Stmt) ColumnInt(idx Int) Int { return 0 }
+func (stmt *Stmt) ColumnInt(idx c.Int) c.Int { return 0 }
 
 // llgo:link (*Stmt).ColumnInt64 C.sqlite3_column_int64
-func (stmt *Stmt) ColumnInt64(idx Int) int64 { return 0 }
+func (stmt *Stmt) ColumnInt64(idx c.Int) int64 { return 0 }
 
 // llgo:link (*Stmt).ColumnText C.sqlite3_column_text
-func (stmt *Stmt) ColumnText(idx Int) *Char { return nil }
+func (stmt *Stmt) ColumnText(idx c.Int) *c.Char { return nil }
 
 // -----------------------------------------------------------------------------
 
@@ -258,8 +254,8 @@ func (stmt *Stmt) ColumnText(idx Int) *Char { return nil }
 //
 // llgo:link (*Sqlite3).Exec C.sqlite3_exec
 func (*Sqlite3) Exec(
-	sql *Char, callback func(arg Pointer, resultCols Int, colVals, colNames **Char) Int,
-	arg Pointer, errmsg **Char) Errno {
+	sql *c.Char, callback func(arg c.Pointer, resultCols c.Int, colVals, colNames **c.Char) c.Int,
+	arg c.Pointer, errmsg **c.Char) Errno {
 	return 0
 }