121 lines
2.6 KiB
Go
121 lines
2.6 KiB
Go
package env
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
LLGoCompilerPkg = "github.com/goplus/llgo"
|
|
LLGoRuntimePkgName = "runtime"
|
|
LLGoRuntimePkg = LLGoCompilerPkg + "/" + LLGoRuntimePkgName
|
|
envFileName = "/compiler/internal/env/env.go"
|
|
)
|
|
|
|
func GOROOT() string {
|
|
root := os.Getenv("GOROOT")
|
|
if root != "" {
|
|
return root
|
|
}
|
|
cmd := exec.Command("go", "env", "GOROOT")
|
|
var out bytes.Buffer
|
|
cmd.Stdout = &out
|
|
err := cmd.Run()
|
|
if err == nil {
|
|
return strings.TrimSpace(out.String())
|
|
}
|
|
panic("cannot get GOROOT: " + err.Error())
|
|
}
|
|
|
|
func LLGoRuntimeDir() string {
|
|
root := LLGoROOT()
|
|
if root != "" {
|
|
return filepath.Join(root, LLGoRuntimePkgName)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func LLGoROOT() string {
|
|
llgoRootEnv := os.Getenv("LLGO_ROOT")
|
|
if llgoRootEnv != "" {
|
|
if root, ok := isLLGoRoot(llgoRootEnv); ok {
|
|
return root
|
|
}
|
|
fmt.Fprintf(os.Stderr, "WARNING: LLGO_ROOT is not a valid LLGO root: %s\n", llgoRootEnv)
|
|
}
|
|
// Get executable path
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
// Resolve any symlinks
|
|
exe, err = filepath.EvalSymlinks(exe)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
// Check if parent directory is bin
|
|
dir := filepath.Dir(exe)
|
|
if filepath.Base(dir) == "bin" {
|
|
// Get parent directory of bin
|
|
root := filepath.Dir(dir)
|
|
if root, ok := isLLGoRoot(root); ok {
|
|
return root
|
|
}
|
|
}
|
|
if Devel() {
|
|
root, err := getRuntimePkgDirByCaller()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
if root, ok := isLLGoRoot(root); ok {
|
|
fmt.Fprintln(os.Stderr, "WARNING: Using LLGO root for devel: "+root)
|
|
return root
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func isLLGoRoot(root string) (string, bool) {
|
|
if root == "" {
|
|
return "", false
|
|
}
|
|
root, err := filepath.Abs(root)
|
|
if err != nil {
|
|
return "", false
|
|
}
|
|
// Check for go.mod
|
|
data, err := os.ReadFile(filepath.Join(root, LLGoRuntimePkgName, "go.mod"))
|
|
if err != nil {
|
|
return "", false
|
|
}
|
|
// Check module name
|
|
if !strings.Contains(string(data), "module "+LLGoRuntimePkg+"\n") {
|
|
return "", false
|
|
}
|
|
return root, true
|
|
}
|
|
|
|
func getRuntimePkgDirByCaller() (string, error) {
|
|
_, file, _, ok := runtime.Caller(0)
|
|
if !ok {
|
|
return "", fmt.Errorf("cannot get caller")
|
|
}
|
|
if !strings.HasSuffix(file, envFileName) {
|
|
return "", fmt.Errorf("wrong caller")
|
|
}
|
|
// check file exists
|
|
if _, err := os.Stat(file); os.IsNotExist(err) {
|
|
return "", fmt.Errorf("file %s not exists", file)
|
|
}
|
|
modPath := strings.TrimSuffix(file, envFileName)
|
|
if st, err := os.Stat(modPath); os.IsNotExist(err) || !st.IsDir() {
|
|
return "", fmt.Errorf("not llgo compiler root: %s", modPath)
|
|
}
|
|
return modPath, nil
|
|
}
|