move out c/cpp/py

cmd/internal/base/base.go

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2023 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 base defines shared basic pieces of the llgo command,
+// in particular logging and the Command structure.
+package base
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// A Command is an implementation of a gop command
+// like gop export or gop install.
+type Command struct {
+	// Run runs the command.
+	// The args are the arguments after the command name.
+	Run func(cmd *Command, args []string)
+
+	// UsageLine is the one-line usage message.
+	// The words between "gop" and the first flag or argument in the line are taken to be the command name.
+	UsageLine string
+
+	// Short is the short description shown in the 'gop help' output.
+	Short string
+
+	// Flag is a set of flags specific to this command.
+	Flag flag.FlagSet
+
+	// Commands lists the available commands and help topics.
+	// The order here is the order in which they are printed by 'gop help'.
+	// Note that subcommands are in general best avoided.
+	Commands []*Command
+}
+
+// Llgo command
+var Llgo = &Command{
+	UsageLine: "llgo",
+	Short:     `llgo is a Go compiler based on LLVM in order to better integrate Go with the C ecosystem including Python.`,
+	// Commands initialized in package main
+}
+
+// LongName returns the command's long name: all the words in the usage line between "gop" and a flag or argument,
+func (c *Command) LongName() string {
+	name := c.UsageLine
+	if i := strings.Index(name, " ["); i >= 0 {
+		name = name[:i]
+	}
+	if name == "llgo" {
+		return ""
+	}
+	return strings.TrimPrefix(name, "llgo ")
+}
+
+// Name returns the command's short name: the last word in the usage line before a flag or argument.
+func (c *Command) Name() string {
+	name := c.LongName()
+	if i := strings.LastIndex(name, " "); i >= 0 {
+		name = name[i+1:]
+	}
+	return name
+}
+
+// Usage show the command usage.
+func (c *Command) Usage(w io.Writer) {
+	fmt.Fprintf(w, "%s\n\nUsage: %s\n", c.Short, c.UsageLine)
+
+	// restore output of flag
+	defer c.Flag.SetOutput(c.Flag.Output())
+
+	c.Flag.SetOutput(w)
+	c.Flag.PrintDefaults()
+	fmt.Fprintln(w)
+}
+
+// Runnable reports whether the command can be run; otherwise
+// it is a documentation pseudo-command.
+func (c *Command) Runnable() bool {
+	return c.Run != nil
+}
+
+// Usage is the usage-reporting function, filled in by package main
+// but here for reference by other packages.
+//
+// flag.Usage func()
+
+// CmdName - "build", "install", "list", "mod tidy", etc.
+var CmdName string
+
+// Main runs a command.
+func Main(c *Command, app string, args []string) {
+	name := c.UsageLine
+	if i := strings.Index(name, " ["); i >= 0 {
+		c.UsageLine = app + name[i:]
+	}
+	c.Run(c, args)
+}

cmd/internal/build/build.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 build implements the "llgo build" command.
+package build
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/build"
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+// llgo build
+var Cmd = &base.Command{
+	UsageLine: "llgo build [-o output] [build flags] [packages]",
+	Short:     "Compile packages and dependencies",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	conf := &build.Config{
+		Mode:   build.ModeBuild,
+		AppExt: build.DefaultAppExt(),
+	}
+	if len(args) >= 2 && args[0] == "-o" {
+		conf.OutFile = args[1]
+		args = args[2:]
+	}
+	_, err := build.Do(args, conf)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		mockable.Exit(1)
+	}
+}

cmd/internal/clean/clean.go

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package clean implements the "llgo clean" command.
+package clean
+
+import (
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/build"
+)
+
+// llgo build
+var Cmd = &base.Command{
+	UsageLine: "llgo clean [clean flags] [build flags] [packages]",
+	Short:     "Remove object files and cached files",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	conf := build.NewDefaultConf(0)
+	build.Clean(args, conf)
+}

cmd/internal/get/get.go

@@ -0,0 +1,36 @@
+/*
+ * 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 get implements the "llgo get" command.
+package get
+
+import (
+	"github.com/goplus/llgo/cmd/internal/base"
+)
+
+// llgo get
+var Cmd = &base.Command{
+	UsageLine: "llgo get [-t -u -v] [build flags] [packages]",
+	Short:     "Add dependencies to current module and install them",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	panic("todo")
+}

cmd/internal/help/help.go

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2023 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 help implements the “llgo help” command.
+package help
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strings"
+	"text/template"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+// Help implements the 'help' command.
+func Help(w io.Writer, args []string) {
+	cmd := base.Llgo
+Args:
+	for i, arg := range args {
+		for _, sub := range cmd.Commands {
+			if sub.Name() == arg {
+				cmd = sub
+				continue Args
+			}
+		}
+
+		// helpSuccess is the help command using as many args as possible that would succeed.
+		helpSuccess := "llgo help"
+		if i > 0 {
+			helpSuccess += " " + strings.Join(args[:i], " ")
+		}
+		fmt.Fprintf(os.Stderr, "llgo help %s: unknown help topic. Run '%s'.\n", strings.Join(args, " "), helpSuccess)
+		mockable.Exit(2)
+	}
+
+	if len(cmd.Commands) > 0 {
+		PrintUsage(w, cmd)
+	} else {
+		cmd.Usage(w)
+	}
+	// not exit 2: succeeded at 'llgo help cmd'.
+}
+
+var usageTemplate = `{{.Short | trim}}
+
+Usage:
+
+	{{.UsageLine}} <command> [arguments]
+
+The commands are:
+{{range .Commands}}{{if or (.Runnable) .Commands}}
+	{{.Name | printf "%-11s"}} {{.Short}}{{end}}{{end}}
+
+Use "llgo help{{with .LongName}} {{.}}{{end}} <command>" for more information about a command.
+
+`
+
+// An errWriter wraps a writer, recording whether a write error occurred.
+type errWriter struct {
+	w   io.Writer
+	err error
+}
+
+func (w *errWriter) Write(b []byte) (int, error) {
+	n, err := w.w.Write(b)
+	if err != nil {
+		w.err = err
+	}
+	return n, err
+}
+
+// tmpl executes the given template text on data, writing the result to w.
+func tmpl(w io.Writer, text string, data interface{}) {
+	t := template.New("top")
+	t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize})
+	template.Must(t.Parse(text))
+	ew := &errWriter{w: w}
+	err := t.Execute(ew, data)
+	if ew.err != nil {
+		// I/O error writing. Ignore write on closed pipe.
+		if strings.Contains(ew.err.Error(), "pipe") {
+			mockable.Exit(1)
+		}
+		log.Fatalf("writing output: %v", ew.err)
+	}
+	if err != nil {
+		panic(err)
+	}
+}
+
+func capitalize(s string) string {
+	if s == "" {
+		return s
+	}
+	r, n := utf8.DecodeRuneInString(s)
+	return string(unicode.ToTitle(r)) + s[n:]
+}
+
+// PrintUsage prints usage information.
+func PrintUsage(w io.Writer, cmd *base.Command) {
+	bw := bufio.NewWriter(w)
+	tmpl(bw, usageTemplate, cmd)
+	bw.Flush()
+}

cmd/internal/install/install.go

@@ -0,0 +1,46 @@
+/*
+ * 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 install implements the "llgo install" command.
+package install
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/build"
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+// llgo install
+var Cmd = &base.Command{
+	UsageLine: "llgo install [build flags] [packages]",
+	Short:     "Compile and install packages and dependencies",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	conf := build.NewDefaultConf(build.ModeInstall)
+	_, err := build.Do(args, conf)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		mockable.Exit(1)
+	}
+}

cmd/internal/run/run.go

@@ -0,0 +1,101 @@
+/*
+ * 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 run implements the "llgo run" command.
+package run
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/build"
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+var (
+	errNoProj = errors.New("llgo: no go files listed")
+)
+
+// llgo run
+var Cmd = &base.Command{
+	UsageLine: "llgo run [build flags] package [arguments...]",
+	Short:     "Compile and run Go program",
+}
+
+// llgo cmptest
+var CmpTestCmd = &base.Command{
+	UsageLine: "llgo cmptest [-gen] [build flags] package [arguments...]",
+	Short:     "Compile and run with llgo, compare result (stdout/stderr/exitcode) with go or llgo.expect; generate llgo.expect file if -gen is specified",
+}
+
+func init() {
+	Cmd.Run = runCmd
+	CmpTestCmd.Run = runCmpTest
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	runCmdEx(cmd, args, build.ModeRun)
+}
+
+func runCmpTest(cmd *base.Command, args []string) {
+	runCmdEx(cmd, args, build.ModeCmpTest)
+}
+
+func runCmdEx(_ *base.Command, args []string, mode build.Mode) {
+	conf := build.NewDefaultConf(mode)
+	if mode == build.ModeCmpTest && len(args) > 0 && args[0] == "-gen" {
+		conf.GenExpect = true
+		args = args[1:]
+	}
+	args, runArgs, err := parseRunArgs(args)
+	check(err)
+	conf.RunArgs = runArgs
+	_, err = build.Do(args, conf)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		mockable.Exit(1)
+	}
+}
+
+func parseRunArgs(args []string) ([]string, []string, error) {
+	n := build.SkipFlagArgs(args)
+	if n < 0 {
+		return nil, nil, errNoProj
+	}
+
+	arg := args[n]
+	if isGoFile(arg) {
+		n++
+		for n < len(args) && isGoFile(args[n]) {
+			n++
+		}
+		return args[:n], args[n:], nil
+	}
+	return args[:n+1], args[n+1:], nil
+}
+
+func isGoFile(fname string) bool {
+	return filepath.Ext(fname) == ".go"
+}
+
+func check(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

cmd/internal/test/test.go

@@ -0,0 +1,33 @@
+package test
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/build"
+)
+
+// llgo test
+var Cmd = &base.Command{
+	UsageLine: "llgo test [build flags] package [arguments...]",
+	Short:     "Compile and run Go test",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	runCmdEx(cmd, args, build.ModeRun)
+}
+
+func runCmdEx(_ *base.Command, args []string, mode build.Mode) {
+	conf := build.NewDefaultConf(mode)
+	conf.Mode = build.ModeTest
+	_, err := build.Do(args, conf)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

cmd/internal/version/version.go

@@ -0,0 +1,39 @@
+/*
+ * 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 version implements the "llgo version" command.
+package version
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/internal/env"
+)
+
+// llgo version
+var Cmd = &base.Command{
+	UsageLine: "llgo version",
+	Short:     "Print LLGo version",
+}
+
+func init() {
+	Cmd.Run = runCmd
+}
+
+func runCmd(cmd *base.Command, args []string) {
+	fmt.Printf("llgo %s %s/%s\n", env.Version(), runtime.GOOS, runtime.GOARCH)
+}

cmd/llgo/llgo.go

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2023 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/qiniu/x/log"
+
+	"github.com/goplus/llgo/cmd/internal/base"
+	"github.com/goplus/llgo/cmd/internal/build"
+	"github.com/goplus/llgo/cmd/internal/clean"
+	"github.com/goplus/llgo/cmd/internal/get"
+	"github.com/goplus/llgo/cmd/internal/help"
+	"github.com/goplus/llgo/cmd/internal/install"
+	"github.com/goplus/llgo/cmd/internal/run"
+	"github.com/goplus/llgo/cmd/internal/test"
+	"github.com/goplus/llgo/cmd/internal/version"
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+func mainUsage() {
+	help.PrintUsage(os.Stderr, base.Llgo)
+}
+
+func init() {
+	flag.Usage = mainUsage
+	base.Llgo.Commands = []*base.Command{
+		build.Cmd,
+		install.Cmd,
+		get.Cmd,
+		run.Cmd,
+		run.CmpTestCmd,
+		test.Cmd,
+		clean.Cmd,
+		version.Cmd,
+	}
+}
+
+func main() {
+	flag.Parse()
+	args := flag.Args()
+	if len(args) < 1 {
+		flag.Usage()
+		return
+	}
+	log.SetFlags(log.Ldefault &^ log.LstdFlags)
+
+	base.CmdName = args[0] // for error messages
+	if args[0] == "help" {
+		help.Help(os.Stderr, args[1:])
+		return
+	}
+
+BigCmdLoop:
+	for bigCmd := base.Llgo; ; {
+		for _, cmd := range bigCmd.Commands {
+			if cmd.Name() != args[0] {
+				continue
+			}
+			args = args[1:]
+			if len(cmd.Commands) > 0 {
+				bigCmd = cmd
+				if len(args) == 0 {
+					help.PrintUsage(os.Stderr, bigCmd)
+					mockable.Exit(2)
+				}
+				if args[0] == "help" {
+					help.Help(os.Stderr, append(strings.Split(base.CmdName, " "), args[1:]...))
+					return
+				}
+				base.CmdName += " " + args[0]
+				continue BigCmdLoop
+			}
+			if !cmd.Runnable() {
+				continue
+			}
+			cmd.Run(cmd, args)
+			return
+		}
+		helpArg := ""
+		if i := strings.LastIndex(base.CmdName, " "); i >= 0 {
+			helpArg = " " + base.CmdName[:i]
+		}
+		fmt.Fprintf(os.Stderr, "llgo %s: unknown command\nRun 'llgo help%s' for usage.\n", base.CmdName, helpArg)
+		mockable.Exit(2)
+	}
+}

cmd/llgo/llgo_test.go

@@ -0,0 +1,396 @@
+//go:build !llgo
+// +build !llgo
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/goplus/llgo/internal/mockable"
+)
+
+func init() {
+	origWd, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+
+	// Set LLGO_ROOT to project root
+	llgoRoot := filepath.Join(origWd, "../..")
+	if err := os.Setenv("LLGO_ROOT", llgoRoot); err != nil {
+		panic(fmt.Sprintf("Failed to set LLGO_ROOT: %v", err))
+	}
+}
+
+func setupTestProject(t *testing.T) string {
+	tmpDir := t.TempDir()
+
+	// Create main.go
+	mainGo := filepath.Join(tmpDir, "main.go")
+	err := os.WriteFile(mainGo, []byte(`package main
+
+import "fmt"
+import "os"
+
+func main() {
+	var arg string = "LLGO"
+	if len(os.Args) > 1 {
+		arg = os.Args[1]
+	}
+	switch arg {
+	case "stderr":
+		fmt.Fprintln(os.Stderr, "Hello, World!")
+	case "exit":
+		os.Exit(1)
+	default:
+		fmt.Println("Hello, " + arg + "!")
+	}
+}
+`), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create main.go: %v", err)
+	}
+
+	// Create llgo.expect for cmptest
+	expectFile := filepath.Join(tmpDir, "llgo.expect")
+	err = os.WriteFile(expectFile, []byte(`#stdout
+Hello, LLGO!
+
+#stderr
+
+#exit 0
+`), 0644)
+	if err != nil {
+		t.Fatalf("Failed to create llgo.expect: %v", err)
+	}
+
+	// Create a go.mod file
+	err = os.WriteFile(filepath.Join(tmpDir, "go.mod"), []byte(`module testproject
+
+go 1.22.0
+`), 0644)
+	if err != nil {
+		t.Fatalf("Failed to write go.mod: %v", err)
+	}
+
+	return tmpDir
+}
+
+func TestProjectCommands(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    []string
+		wantErr bool
+		setup   func(dir string) error
+	}{
+		{
+			name:    "build command",
+			args:    []string{"llgo", "build", "-o", "testproject", "."},
+			wantErr: false,
+		},
+		{
+			name:    "install command",
+			args:    []string{"llgo", "install", "."},
+			wantErr: false,
+		},
+		{
+			name:    "run command",
+			args:    []string{"llgo", "run", "."},
+			wantErr: false,
+		},
+		{
+			name:    "run command with file",
+			args:    []string{"llgo", "run", "main.go"},
+			wantErr: false,
+		},
+		{
+			name:    "run command verbose",
+			args:    []string{"llgo", "run", "-v", "."},
+			wantErr: false,
+		},
+		{
+			name:    "clean command",
+			args:    []string{"llgo", "clean"},
+			wantErr: false,
+		},
+		{
+			name:    "cmptest command",
+			args:    []string{"llgo", "cmptest", "."},
+			wantErr: false,
+		},
+		{
+			name:    "cmptest command with gen",
+			args:    []string{"llgo", "cmptest", "-gen", "."},
+			wantErr: false,
+			setup: func(dir string) error {
+				return os.Remove(filepath.Join(dir, "llgo.expect"))
+			},
+		},
+		{
+			name:    "cmptest command with args",
+			args:    []string{"llgo", "cmptest", ".", "World"},
+			wantErr: true,
+			setup: func(dir string) error {
+				return os.WriteFile(filepath.Join(dir, "llgo.expect"), []byte(`#stdout
+Hello, World!
+
+#stderr
+
+#exit 0
+`), 0644)
+			},
+		},
+		{
+			name:    "cmptest command with different stderr",
+			args:    []string{"llgo", "cmptest", ".", "stderr"},
+			wantErr: true,
+		},
+		{
+			name:    "cmptest command with different exit code",
+			args:    []string{"llgo", "cmptest", ".", "exit"},
+			wantErr: true,
+			setup: func(dir string) error {
+				// Create llgo.expect with different exit code
+				return os.WriteFile(filepath.Join(dir, "llgo.expect"), []byte(`#stdout
+Hello, LLGO!
+
+#stderr
+
+#exit 1
+`), 0644)
+			},
+		},
+		{
+			name:    "cmptest command without llgo.expect to compare with go run",
+			args:    []string{"llgo", "cmptest", "."},
+			wantErr: false,
+			setup: func(dir string) error {
+				return os.Remove(filepath.Join(dir, "llgo.expect"))
+			},
+		},
+		{
+			name:    "cmptest command with different go run output",
+			args:    []string{"llgo", "cmptest", "."},
+			wantErr: true,
+			setup: func(dir string) error {
+				// Remove llgo.expect file
+				if err := os.Remove(filepath.Join(dir, "llgo.expect")); err != nil && !os.IsNotExist(err) {
+					return err
+				}
+
+				// Create main_llgo.go for llgo
+				if err := os.WriteFile(filepath.Join(dir, "main_llgo.go"), []byte(`//go:build llgo
+// +build llgo
+
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, LLGO!")
+}
+`), 0644); err != nil {
+					return err
+				}
+
+				// Create main_go.go for go
+				return os.WriteFile(filepath.Join(dir, "main.go"), []byte(`//go:build !llgo
+// +build !llgo
+
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, Go!")
+}
+`), 0644)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var testErr error
+			const maxAttempts = 4
+			for attempt := 1; attempt <= maxAttempts; attempt++ {
+				testErr = func() error {
+					// Create a new test directory for each test case
+					tmpDir := setupTestProject(t)
+					defer os.RemoveAll(tmpDir)
+
+					// Change to test project directory
+					if err := os.Chdir(tmpDir); err != nil {
+						return fmt.Errorf("Failed to change directory: %v", err)
+					}
+
+					if tt.setup != nil {
+						if err := tt.setup(tmpDir); err != nil {
+							return fmt.Errorf("Failed to setup test: %v", err)
+						}
+					}
+
+					mockable.EnableMock()
+					var exitErr error
+					func() {
+						defer func() {
+							if r := recover(); r != nil {
+								if r != "exit" {
+									if !tt.wantErr {
+										exitErr = fmt.Errorf("unexpected panic: %v", r)
+									}
+								} else {
+									exitCode := mockable.ExitCode()
+									if (exitCode != 0) != tt.wantErr {
+										exitErr = fmt.Errorf("got exit code %d, wantErr %v", exitCode, tt.wantErr)
+									}
+								}
+							}
+						}()
+
+						os.Args = tt.args
+						main()
+					}()
+					if exitErr != nil {
+						return exitErr
+					}
+
+					// For build/install commands, check if binary was created
+					if strings.HasPrefix(tt.name, "build") || strings.HasPrefix(tt.name, "install") {
+						binName := "testproject"
+						var binPath string
+						if strings.HasPrefix(tt.name, "install") {
+							// For install command, binary should be in GOBIN or GOPATH/bin
+							gobin := os.Getenv("GOBIN")
+							if gobin == "" {
+								gopath := os.Getenv("GOPATH")
+								if gopath == "" {
+									gopath = filepath.Join(os.Getenv("HOME"), "go")
+								}
+								gobin = filepath.Join(gopath, "bin")
+							}
+							binPath = filepath.Join(gobin, binName)
+						} else {
+							// For build command, binary should be in current directory
+							binPath = filepath.Join(tmpDir, binName)
+						}
+						if _, err := os.Stat(binPath); os.IsNotExist(err) {
+							return fmt.Errorf("Binary %s was not created at %s", binName, binPath)
+						}
+					}
+					return nil
+				}()
+
+				if testErr == nil {
+					break
+				}
+
+				if attempt < maxAttempts {
+					t.Logf("Test failed on attempt %v/%v: %v. Retrying...", testErr, attempt, maxAttempts)
+				}
+			}
+
+			if testErr != nil {
+				t.Error(testErr)
+			}
+		})
+	}
+}
+
+func _TestCommandHandling(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    []string
+		wantErr bool
+	}{
+		{
+			name:    "version command",
+			args:    []string{"llgo", "version"},
+			wantErr: false,
+		},
+		{
+			name:    "help command",
+			args:    []string{"llgo", "help"},
+			wantErr: false,
+		},
+		{
+			name:    "invalid command",
+			args:    []string{"llgo", "invalid"},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					if r != "exit" {
+						t.Errorf("unexpected panic: %v", r)
+					}
+					exitCode := mockable.ExitCode()
+					if (exitCode != 0) != tt.wantErr {
+						t.Errorf("got exit code %d, wantErr %v", exitCode, tt.wantErr)
+					}
+				}
+			}()
+
+			os.Args = tt.args
+			main()
+		})
+	}
+}
+
+func TestHelpCommand(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+	}{
+		{
+			name: "help build",
+			args: []string{"llgo", "help", "build"},
+		},
+		{
+			name: "help install",
+			args: []string{"llgo", "help", "install"},
+		},
+		{
+			name: "help run",
+			args: []string{"llgo", "help", "run"},
+		},
+		{
+			name: "help version",
+			args: []string{"llgo", "help", "version"},
+		},
+		{
+			name: "help clean",
+			args: []string{"llgo", "help", "clean"},
+		},
+		{
+			name: "help cmptest",
+			args: []string{"llgo", "help", "cmptest"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					if r != "exit" {
+						t.Errorf("unexpected panic: %v", r)
+					}
+					exitCode := mockable.ExitCode()
+					if exitCode != 0 {
+						t.Errorf("got exit code %d, want 0", exitCode)
+					}
+				}
+			}()
+
+			os.Args = tt.args
+			main()
+		})
+	}
+}