source: code/trunk/vendor/modernc.org/ccgo/v3/lib/ccgo.go@ 822

// Copyright 2020 The CCGO Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate stringer -output stringer.go -type=exprMode,opKind

// Package ccgo implements the ccgo command.
package ccgo // import "modernc.org/ccgo/v3/lib"

import (
        "bufio"
        "bytes"
        "encoding/csv"
        "encoding/json"
        "fmt"
        "go/ast"
        "go/build"
        "go/parser"
        "go/token"
        "io"
        "io/ioutil"
        "os"
        "os/exec"
        "path/filepath"
        "regexp"
        "runtime"
        "runtime/debug"
        "sort"
        "strconv"
        "strings"
        "time"

        "github.com/kballard/go-shellquote"
        "golang.org/x/tools/go/packages"
        "modernc.org/cc/v3"
        "modernc.org/libc"
        "modernc.org/opt"
)

const (
        Version = "3.12.6-20210922111124"

        experimentsEnvVar = "CCGO_EXPERIMENT"
        maxSourceLine     = 1 << 20
)

var (
        _ = libc.Xstdin

        coverExperiment bool
)

func init() {
        s := strings.TrimSpace(os.Getenv(experimentsEnvVar))
        if s == "" {
                return
        }

        for _, v := range strings.Split(s, ",") {
                switch strings.TrimSpace(v) {
                case "cover":
                        coverExperiment = true
                }
        }
}

//TODO CPython
//TODO Cython
//TODO gmp
//TODO gofrontend
//TODO gsl
//TODO minigmp
//TODO mpc
//TODO mpfr
//TODO pcre
//TODO pcre2
//TODO quickjs
//TODO redis
//TODO sdl2
//TODO wolfssl
//TODO zdat
//TODO zstd

//TODO 2020-07-17
//
// Fix += and friends
//
// Audit all unsafe.Pointer conversions
//
// Remove double dereferencing **
//
// Shifts must not use n.Promote on left opearand
//
// Un-array
//
// Pass more CSmith tests.

//TODO merge VaList slots of distinct top level statements.

//TODO turn void
//
//      a = b = c = d
//
// where all but the first and last of a, b, c, ... are declarators, into
//
//      c = d
//      b = c
//      a = b

//TODO define and use all tagged struct types, including inner ones, for example SQLite's SrcList_item.

//TODO rewrite return conditionalExpression so it has no closures. Partially done.

//TODO define and restore simple named constants. Having
//
//      #define FOO 42
//      ...
//      case FOO:
//
// we do not yet define FOO and generate
//
//      case 42:

//TODO do not generate a terminating semicolon for empty statements.

//TODO replace
//
//      var sqlite3_data_directory uintptr = uintptr(0) /* sqlite3.c:156345:17 */
//
// by
//
//      var sqlite3_data_directory uintptr = 0 /* sqlite3.c:156345:17 */
//
// or
//
//      var sqlite3_data_directory = uintptr(0) /* sqlite3.c:156345:17 */

//TODO drop all non-referenced declarators unless forced by a command line flag.

const (
        builtin = `
#ifdef __PTRDIFF_TYPE__
typedef __PTRDIFF_TYPE__ ptrdiff_t;
#else
#error __PTRDIFF_TYPE__ undefined
#endif

#ifdef __SIZE_TYPE__
typedef __SIZE_TYPE__ size_t;
#else
#error __SIZE_TYPE__ undefined
#endif

#ifdef __WCHAR_TYPE__
typedef __WCHAR_TYPE__ wchar_t;
#else
#error __WCHAR_TYPE__ undefined
#endif

#ifdef __SIZEOF_INT128__
typedef struct { __INT64_TYPE__ lo, hi; } __int128_t;   // must match modernc.org/mathutil.Int128
typedef struct { __UINT64_TYPE__ lo, hi; } __uint128_t; // must match modernc.org/mathutil.Int128
#endif;

#define _FILE_OFFSET_BITS 64
#define __FUNCTION__ __func__
#define __PRETTY_FUNCTION__ __func__
#define __asm __asm__
#define __builtin_constant_p(x) __builtin_constant_p_impl(0, x)
#define __builtin_offsetof(type, member) ((__SIZE_TYPE__)&(((type*)0)->member))
#define __builtin_va_arg(ap, type) ((type)__ccgo_va_arg(ap))
#define __builtin_va_copy(dst, src) dst = src
#define __builtin_va_end(ap) __ccgo_va_end(ap)
#define __builtin_va_start(ap, v) __ccgo_va_start(ap)
#define __ccgo_fd_zero(set) __builtin_memset(set, 0, sizeof(fd_set))
#define __ccgo_tcl_default_double_rounding(set) ((void)0)
#define __ccgo_tcl_ieee_double_rounding(set) ((void)0)
#define __extension__
#define __has_include(...) __has_include_impl(#__VA_ARGS__)
#define __has_include_impl(x)
#define __inline__ inline
#define __signed signed
#define asm __asm__
#define in6addr_any (*__ccgo_in6addr_anyp())

typedef void *__builtin_va_list;
typedef long double __float128;

#if defined(__MINGW32__) || defined(__MINGW64__)
typedef __builtin_va_list va_list;
int gnu_printf(const char *format, ...);
int gnu_scanf(const char *format, ...);
int ms_printf(const char *format, ...);
int ms_scanf(const char *format, ...);
#define _VA_LIST_DEFINED
#define __extension__
#endif

__UINT16_TYPE__ __builtin_bswap16 (__UINT16_TYPE__ x);
__UINT32_TYPE__ __builtin_bswap32 (__UINT32_TYPE__ x);
__UINT64_TYPE__ __builtin_bswap64 (__UINT64_TYPE__ x);
char *__builtin___strcat_chk (char *dest, const char *src, size_t os);
char *__builtin___strcpy_chk (char *dest, const char *src, size_t os);
char *__builtin___strncpy_chk(char *dest, char *src, size_t n, size_t os);
char *__builtin_strchr(const char *s, int c);
char *__builtin_strcpy(char *dest, const char *src);
double __builtin_copysign ( double x, double y );
double __builtin_copysignl (long double x, long double y );
double __builtin_fabs(double x);
double __builtin_huge_val (void);
double __builtin_inf (void);
double __builtin_nan (const char *str);
float __builtin_copysignf ( float x, float y );
float __builtin_fabsf(float x);
float __builtin_huge_valf (void);
float __builtin_inff (void);
float __builtin_nanf (const char *str);
int __builtin___snprintf_chk (char *s, size_t maxlen, int flag, size_t os, const char *fmt, ...);
int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...);
int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os, const char *fmt, __builtin_va_list ap);
int __builtin__snprintf_chk(char * str, size_t maxlen, int flag, size_t strlen, const char * format);
int __builtin_abs(int j);
int __builtin_add_overflow();
int __builtin_clz (unsigned);
int __builtin_isunordered(double x, double y);
int __builtin_clzl (unsigned long);
int __builtin_clzll (unsigned long long);
int __builtin_constant_p_impl(int, ...);
int __builtin_getentropy(void*, size_t);
int __builtin_isnan(double);
int __builtin_memcmp(const void *s1, const void *s2, size_t n);
int __builtin_mul_overflow();
int __builtin_popcount (unsigned int x);
int __builtin_popcountl (unsigned long x);
int __builtin_printf(const char *format, ...);
int __builtin_snprintf(char *str, size_t size, const char *format, ...);
int __builtin_sprintf(char *str, const char *format, ...);
int __builtin_strcmp(const char *s1, const char *s2);
int __builtin_sub_overflow();
long __builtin_expect (long exp, long c);
long double __builtin_fabsl(long double x);
long double __builtin_nanl (const char *str);
long long __builtin_llabs(long long j);
size_t __builtin_object_size (void * ptr, int type);
size_t __builtin_strlen(const char *s);
void *__builtin___memcpy_chk (void *dest, const void *src, size_t n, size_t os);
void *__builtin___memmove_chk (void *dest, const void *src, size_t n, size_t os);
void *__builtin___memset_chk (void *dstpp, int c, size_t len, size_t dstlen);
void *__builtin_malloc(size_t size);
void *__builtin_memcpy(void *dest, const void *src, size_t n);
void *__builtin_memset(void *s, int c, size_t n);
void *__builtin_mmap(void *addr, size_t length, int prot, int flags, int fd, __INTPTR_TYPE__ offset);
void *__ccgo_va_arg(__builtin_va_list ap);
void __builtin_abort(void);
void __builtin_bzero(void *s, size_t n);
void __builtin_exit(int status);
void __builtin_free(void *ptr);
void __builtin_prefetch (const void *addr, ...);
void __builtin_trap (void);
void __builtin_unreachable (void);
void __ccgo_dmesg(char*, ...);
void __ccgo_va_end(__builtin_va_list ap);
void __ccgo_va_start(__builtin_va_list ap);

#define __sync_add_and_fetch(ptr, val) \
        __builtin_choose_expr(  \
                __builtin_types_compatible_p(typeof(*ptr), unsigned),   \
                __sync_add_and_fetch_uint32(ptr, val),  \
                __TODO__        \
        )

#define __sync_fetch_and_add(ptr, val) \
        __TODO__        \

#define __sync_sub_and_fetch(ptr, val) \
        __builtin_choose_expr(  \
                __builtin_types_compatible_p(typeof(*ptr), unsigned),   \
                __sync_sub_and_fetch_uint32(ptr, val),  \
                __TODO__        \
        )

unsigned __sync_add_and_fetch_uint32(unsigned*, unsigned);
unsigned __sync_sub_and_fetch_uint32(unsigned*, unsigned);

#ifdef __APPLE__
int (*__darwin_check_fd_set_overflow)(int, void *, int);
#endif

`
        defaultCrt = "modernc.org/libc"
)

func origin(skip int) string {
        pc, fn, fl, _ := runtime.Caller(skip)
        f := runtime.FuncForPC(pc)
        var fns string
        if f != nil {
                fns = f.Name()
                if x := strings.LastIndex(fns, "."); x > 0 {
                        fns = fns[x+1:]
                }
        }
        return fmt.Sprintf("%s:%d:%s", fn, fl, fns)
}

func todo(s string, args ...interface{}) string {
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        r := fmt.Sprintf("%s\n\tTODO %s", origin(2), s) //TODOOK
        fmt.Fprintf(os.Stdout, "%s\n", r)
        os.Stdout.Sync()
        return r
}

func trc(s string, args ...interface{}) string {
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        r := fmt.Sprintf("%s: TRC %s", origin(2), s)
        fmt.Fprintf(os.Stderr, "%s\n", r)
        os.Stderr.Sync()
        return r
}

// Task represents a compilation job.
type Task struct {
        D                               []string // -D
        I                               []string // -I
        U                               []string // -U
        ar                              string   // $AR, default "ar"
        arLookPath                      string   // LookPath(ar)
        args                            []string
        asts                            []*cc.AST
        capif                           string
        saveConfig                      string // -save-config
        saveConfigErr                   error
        cc                              string // $CC, default "gcc"
        ccLookPath                      string // LookPath(cc)
        cdb                             string // foo.json, use compile DB
        cfg                             *cc.Config
        compiledb                       string // -compiledb
        crt                             string
        crtImportPath                   string // -crt-import-path
        exportDefines                   string // -export-defines
        exportEnums                     string // -export-enums
        exportExterns                   string // -export-externs
        exportFields                    string // -export-fields
        exportStructs                   string // -export-structs
        exportTypedefs                  string // -export-typedefs
        goarch                          string
        goos                            string
        hide                            map[string]struct{} // -hide
        hostConfigCmd                   string              // -host-config-cmd
        hostConfigOpts                  string              // -host-config-opts
        hostIncludes                    []string
        hostPredefined                  string
        hostSysIncludes                 []string
        ignoredIncludes                 string              // -ignored-includes
        ignoredObjects                  map[string]struct{} // -ignore-object
        imported                        []*imported
        includedFiles                   map[string]struct{}
        l                               []string // -l
        loadConfig                      string   // --load-config
        o                               string   // -o
        out                             io.Writer
        pkgName                         string // -pkgname
        replaceFdZero                   string // -replace-fd-zero
        replaceTclDefaultDoubleRounding string // -replace-tcl-default-double-rounding
        replaceTclIeeeDoubleRounding    string // -replace-tcl-default-double-rounding
        scriptFn                        string // -script
        sources                         []cc.Source
        staticLocalsPrefix              string // -static-locals-prefix
        stderr                          io.Writer
        stdout                          io.Writer
        symSearchOrder                  []int                    // >= 0: asts[i], < 0 : imported[-i-1]
        verboseCompiledb                bool                     // -verbose-compiledb
        volatiles                       map[cc.StringID]struct{} // -volatile

        // Path to a binary that will be called instead of executing
        // Task.Main().  Intended to support TestGenerate in stable vs latest
        // modes. This is _not_ supposed to be used when the Task instance is
        // constructed by a ccgo _command_ (ccgo/v3) - it should never set this
        // field. Only programs importing ccgo/v3/lib that opt-in into this
        // feature should ever set it.
        CallOutBinary string

        E                         bool // -E
        allErrors                 bool // -all-errors
        compiledbValid            bool // -compiledb present
        configSaved               bool
        configured                bool // hostPredefined, hostIncludes, hostSysIncludes are valid
        cover                     bool // -cover-instrumentation
        coverC                    bool // -cover-instrumentation-c
        defaultUnExport           bool // -unexported-by-default
        errTrace                  bool // -err-trace
        exportDefinesValid        bool // -export-defines present
        exportEnumsValid          bool // -export-enums present
        exportExternsValid        bool // -export-externs present
        exportFieldsValid         bool // -export-fields present
        exportStructsValid        bool // -export-structs present
        exportTypedefsValid       bool // -export-typedefs present
        fullPathComments          bool // -full-path-comments
        funcSig                   bool // -func-sig
        header                    bool // -header
        ignoreUnsupportedAligment bool // -ignore-unsupported-alignment
        isScripted                bool
        mingw                     bool
        noCapi                    bool // -nocapi
        nostdinc                  bool // -nostdinc
        nostdlib                  bool // -nostdlib
        panicStubs                bool // -panic-stubs
        tracePinning              bool // -trace-pinning
        traceTranslationUnits     bool // -trace-translation-units
        verifyStructs             bool // -verify-structs
        version                   bool // -version
        watch                     bool // -watch-instrumentation
        windows                   bool // -windows
}

// NewTask returns a newly created Task.
func NewTask(args []string, stdout, stderr io.Writer) *Task {
        if dmesgs {
                dmesg("%v: %v", origin(1), args)
        }
        if stdout == nil {
                stdout = os.Stdout
        }
        if stderr == nil {
                stderr = os.Stderr
        }
        return &Task{
                args: args,
                cfg: &cc.Config{
                        Config3: cc.Config3{
                                MaxSourceLine: maxSourceLine,
                        },
                        DoNotTypecheckAsm:                     true,
                        EnableAssignmentCompatibilityChecking: true,
                        LongDoubleIsDouble:                    true,
                        SharedFunctionDefinitions:             &cc.SharedFunctionDefinitions{},
                },
                ar:            env("AR", "ar"),
                cc:            env("CC", "gcc"),
                crt:           "libc.",
                crtImportPath: defaultCrt,
                goarch:        env("TARGET_GOARCH", env("GOARCH", runtime.GOARCH)),
                goos:          env("TARGET_GOOS", env("GOOS", runtime.GOOS)),
                hide:          map[string]struct{}{},
                hostConfigCmd: env("CCGO_CPP", ""),
                pkgName:       "main",
                stderr:        stderr,
                stdout:        stdout,
                volatiles:     map[cc.StringID]struct{}{},
        }
}

func env(name, deflt string) (r string) {
        r = deflt
        if s := os.Getenv(name); s != "" {
                r = s
        }
        return r
}

// Get exported symbols from package having import path 'path'.
func (t *Task) capi(path string) (pkgName string, exports map[string]struct{}, err error) {
        // defer func() {
        //      var a []string
        //      for k := range exports {
        //              a = append(a, k)
        //      }
        //      sort.Strings(a)
        //      trc("%s\n%s", path, strings.Join(a, "\n"))
        // }()
        var errModule, errGopath error
        defer func() {
                if err != nil {
                        a := []string{err.Error()}
                        if errModule != nil {
                                a = append(a, fmt.Sprintf("module mode error: %s", errModule))
                        }
                        if errGopath != nil {
                                a = append(a, fmt.Sprintf("gopath mode error: %s", errGopath))
                        }
                        wd, err2 := os.Getwd()
                        err = fmt.Errorf(
                                "(wd %q, %v): loading C exports from %s (GOPATH=%v GO111MODULE=%v): %v",
                                wd, err2, path, os.Getenv("GOPATH"), os.Getenv("GO111MODULE"), strings.Join(a, "\n\t"),
                        )
                }
        }()

        mod := os.Getenv("GO111MODULE")
        if mod == "" || mod == "on" {
                var pkgs []*packages.Package
                pkgs, errModule = packages.Load(
                        &packages.Config{
                                Mode: packages.NeedFiles,
                                Env:  append(os.Environ(), fmt.Sprintf("GOOS=%s", t.goos), fmt.Sprintf("GOARCH=%s", t.goarch)),
                        },
                        path,
                )
                switch {
                case errModule == nil:
                        if len(pkgs) != 1 {
                                errModule = fmt.Errorf("expected one package, loaded %d", len(pkgs))
                                break
                        }

                        pkg := pkgs[0]
                        if len(pkg.Errors) != 0 {
                                var a []string
                                for _, v := range pkg.Errors {
                                        a = append(a, v.Error())
                                }
                                errModule = fmt.Errorf("%s", strings.Join(a, "\n"))
                                break
                        }

                        return t.capi2(pkg.GoFiles)
                }
        }

        gopath0 := os.Getenv("GOPATH")
        for _, gopath := range strings.Split(gopath0, string(os.PathListSeparator)) {
                if gopath == "" || !filepath.IsAbs(gopath) {
                        continue
                }

                ctx := build.Context{
                        GOARCH:   t.goarch,
                        GOOS:     t.goos,
                        GOPATH:   gopath,
                        Compiler: "gc",
                }
                arg := filepath.Join(gopath, "src", path)
                pkg, err := ctx.ImportDir(arg, 0)
                if err != nil {
                        errGopath = err
                        continue
                }

                for i, v := range pkg.GoFiles {
                        pkg.GoFiles[i] = filepath.Join(gopath, "src", path, v)
                }
                return t.capi2(pkg.GoFiles)
        }
        return "", nil, fmt.Errorf("cannot load CAPI")
}

func (t *Task) capi2(files []string) (pkgName string, exports map[string]struct{}, err error) {
        exports = map[string]struct{}{}
        base := fmt.Sprintf("capi_%s_%s.go", t.goos, t.goarch)
        var fn string
        for _, v := range files {
                if filepath.Base(v) == base {
                        fn = v
                        break
                }
        }
        if fn == "" {
                return "", nil, fmt.Errorf("file %s not found", base)
        }

        fset := token.NewFileSet()
        file, err := parser.ParseFile(fset, fn, nil, 0)
        if err != nil {
                return "", nil, err
        }

        obj, ok := file.Scope.Objects["CAPI"]
        if !ok {
                return "", nil, fmt.Errorf("CAPI not declared in %s", fn)
        }

        switch obj.Kind {
        case ast.Var:
                // ok
        default:
                return "", nil, fmt.Errorf("unexpected CAPI object kind: %v", obj.Kind)
        }

        spec, ok := obj.Decl.(*ast.ValueSpec)
        if !ok {
                return "", nil, fmt.Errorf("unexpected CAPI object type: %T", obj.Decl)
        }

        if len(spec.Values) != 1 {
                return "", nil, fmt.Errorf("expected one CAPI expression, got %v", len(spec.Values))
        }

        ast.Inspect(spec.Values[0], func(n ast.Node) bool {
                if x, ok := n.(*ast.BasicLit); ok {
                        var key string
                        if key, err = strconv.Unquote(x.Value); err != nil {
                                err = fmt.Errorf("invalid CAPI key value: %s", x.Value)
                                return false
                        }

                        exports[key] = struct{}{}
                }
                return true
        })
        return file.Name.String(), exports, err
}

// Main executes task.
func (t *Task) Main() (err error) {
        if dmesgs {
                defer func() {
                        if err != nil {
                                // trc("FAIL %p: %q: %v", t, t.args, err)
                                dmesg("%v: returning from Task.Main: %v", origin(1), err)
                        }
                }()

        }

        defer func() {
                if t.saveConfigErr != nil && err == nil {
                        err = t.saveConfigErr
                }
        }()

        if !t.isScripted && coverExperiment {
                defer func() {
                        fmt.Fprintf(os.Stderr, "cover report:\n%s\n", coverReport())
                }()
        }
        if t.CallOutBinary != "" {
                if dmesgs {
                        dmesg("%v: calling out '%s' instead", origin(1))
                }
                cmd := exec.Command(t.CallOutBinary, t.args[1:]...)
                out, err := cmd.CombinedOutput()
                if err != nil {
                        err = fmt.Errorf("%v\n%s", err, out)
                }
                return err
        }

        opts := opt.NewSet()
        opts.Arg("D", true, func(arg, value string) error { t.D = append(t.D, value); return nil })
        opts.Arg("I", true, func(opt, arg string) error { t.I = append(t.I, arg); return nil })
        opts.Arg("U", true, func(arg, value string) error { t.U = append(t.U, value); return nil })
        opts.Arg("compiledb", false, func(arg, value string) error { t.compiledb = value; t.compiledbValid = true; return opt.Skip(nil) })
        opts.Arg("crt-import-path", false, func(arg, value string) error { t.crtImportPath = value; return nil })
        opts.Arg("export-defines", false, func(arg, value string) error { t.exportDefines = value; t.exportDefinesValid = true; return nil })
        opts.Arg("export-enums", false, func(arg, value string) error { t.exportEnums = value; t.exportEnumsValid = true; return nil })
        opts.Arg("export-externs", false, func(arg, value string) error { t.exportExterns = value; t.exportExternsValid = true; return nil })
        opts.Arg("export-fields", false, func(arg, value string) error { t.exportFields = value; t.exportFieldsValid = true; return nil })
        opts.Arg("export-structs", false, func(arg, value string) error { t.exportStructs = value; t.exportStructsValid = true; return nil })
        opts.Arg("export-typedefs", false, func(arg, value string) error { t.exportTypedefs = value; t.exportTypedefsValid = true; return nil })
        opts.Arg("host-config-cmd", false, func(arg, value string) error { t.hostConfigCmd = value; return nil })
        opts.Arg("host-config-opts", false, func(arg, value string) error { t.hostConfigOpts = value; return nil })
        opts.Arg("ignored-includes", false, func(arg, value string) error { t.ignoredIncludes = value; return nil })
        opts.Arg("pkgname", false, func(arg, value string) error { t.pkgName = value; return nil })
        opts.Arg("replace-fd-zero", false, func(arg, value string) error { t.replaceFdZero = value; return nil })
        opts.Arg("replace-tcl-default-double-rounding", false, func(arg, value string) error { t.replaceTclDefaultDoubleRounding = value; return nil })
        opts.Arg("replace-tcl-ieee-double-rounding", false, func(arg, value string) error { t.replaceTclIeeeDoubleRounding = value; return nil })
        opts.Arg("script", false, func(arg, value string) error { t.scriptFn = value; return nil })
        opts.Arg("static-locals-prefix", false, func(arg, value string) error { t.staticLocalsPrefix = value; return nil })

        opts.Opt("E", func(opt string) error { t.E = true; return nil })
        opts.Opt("all-errors", func(opt string) error { t.allErrors = true; return nil })
        opts.Opt("cover-instrumentation", func(opt string) error { t.cover = true; return nil })
        opts.Opt("cover-instrumentation-c", func(opt string) error { t.coverC = true; return nil })
        opts.Opt("err-trace", func(opt string) error { t.errTrace = true; return nil })
        opts.Opt("full-path-comments", func(opt string) error { t.fullPathComments = true; return nil })
        opts.Opt("func-sig", func(opt string) error { t.funcSig = true; return nil })
        opts.Opt("header", func(opt string) error { t.header = true; return nil })
        opts.Opt("ignore-unsupported-alignment", func(opt string) error { t.ignoreUnsupportedAligment = true; return nil })
        opts.Opt("nocapi", func(opt string) error { t.noCapi = true; return nil })
        opts.Opt("nostdinc", func(opt string) error { t.nostdinc = true; return nil })
        opts.Opt("panic-stubs", func(opt string) error { t.panicStubs = true; return nil })
        opts.Opt("trace-pinning", func(opt string) error { t.tracePinning = true; return nil })
        opts.Opt("trace-translation-units", func(opt string) error { t.traceTranslationUnits = true; return nil })
        opts.Opt("unexported-by-default", func(opt string) error { t.defaultUnExport = true; return nil })
        opts.Opt("verbose-compiledb", func(opt string) error { t.verboseCompiledb = true; return nil })
        opts.Opt("verify-structs", func(opt string) error { t.verifyStructs = true; return nil })
        opts.Opt("version", func(opt string) error { t.version = true; return nil })
        opts.Opt("watch-instrumentation", func(opt string) error { t.watch = true; return nil })
        opts.Opt("windows", func(opt string) error { t.windows = true; return nil })

        opts.Opt("trace-included-files", func(opt string) error {
                if t.includedFiles == nil {
                        t.includedFiles = map[string]struct{}{}
                }
                prev := t.cfg.IncludeFileHandler
                t.cfg.IncludeFileHandler = func(pos token.Position, pathName string) {
                        if prev != nil {
                                prev(pos, pathName)
                        }
                        if _, ok := t.includedFiles[pathName]; !ok {
                                t.includedFiles[pathName] = struct{}{}
                                fmt.Fprintf(os.Stderr, "#include %s\n", pathName)
                        }
                }
                return nil
        })
        opts.Arg("ignore-object", false, func(arg, value string) error {
                if t.ignoredObjects == nil {
                        t.ignoredObjects = map[string]struct{}{}
                }
                t.ignoredObjects[value] = struct{}{}
                return nil
        })
        opts.Arg("save-config", false, func(arg, value string) error {
                if value == "" {
                        return nil
                }

                abs, err := filepath.Abs(value)
                if err != nil {
                        return err
                }

                t.saveConfig = abs
                if t.includedFiles == nil {
                        t.includedFiles = map[string]struct{}{}
                }
                prev := t.cfg.IncludeFileHandler
                t.cfg.IncludeFileHandler = func(pos token.Position, pathName string) {
                        if prev != nil {
                                prev(pos, pathName)
                        }
                        if _, ok := t.includedFiles[pathName]; !ok {
                                t.includedFiles[pathName] = struct{}{}
                                full := filepath.Join(abs, pathName)
                                switch _, err := os.Stat(full); {
                                case err != nil && os.IsNotExist(err):
                                        // ok
                                case err != nil:
                                        t.saveConfigErr = err
                                        return
                                default:
                                        return
                                }

                                b, err := ioutil.ReadFile(pathName)
                                if err != nil {
                                        t.saveConfigErr = err
                                        return
                                }

                                dir, _ := filepath.Split(full)
                                if err := os.MkdirAll(dir, 0700); err != nil {
                                        t.saveConfigErr = err
                                        return
                                }

                                if err := ioutil.WriteFile(full, b, 0600); err != nil {
                                        t.saveConfigErr = err
                                }
                        }
                }
                return nil
        })
        opts.Arg("-load-config", false, func(arg, value string) error {
                if value == "" {
                        return nil
                }

                abs, err := filepath.Abs(value)
                if err != nil {
                        return err
                }

                t.loadConfig = abs
                return nil
        })
        opts.Arg("volatile", false, func(arg, value string) error {
                for _, v := range strings.Split(strings.TrimSpace(value), ",") {
                        t.volatiles[cc.String(v)] = struct{}{}
                }
                return nil
        })
        opts.Opt("nostdlib", func(opt string) error {
                t.nostdlib = true
                t.crt = ""
                t.crtImportPath = ""
                return nil
        })
        opts.Arg("hide", false, func(arg, value string) error {
                value = strings.TrimSpace(value)
                a := strings.Split(value, ",")
                for _, v := range a {
                        t.hide[v] = struct{}{}
                }
                return nil
        })
        opts.Arg("l", true, func(arg, value string) error {
                value = strings.TrimSpace(value)
                a := strings.Split(value, ",")
                for _, v := range a {
                        t.l = append(t.l, v)
                        t.symSearchOrder = append(t.symSearchOrder, -len(t.l))
                }
                return nil
        })
        opts.Arg("o", false, func(arg, value string) error {
                if t.o != "" {
                        return fmt.Errorf("multiple argument: -o %s", value)
                }

                t.o = value
                return nil
        })
        if err := opts.Parse(t.args[1:], func(arg string) error {
                if strings.HasPrefix(arg, "-") {
                        return fmt.Errorf("unexpected option: %s", arg)
                }

                switch filepath.Ext(arg) {
                case ".h":
                        t.symSearchOrder = append(t.symSearchOrder, len(t.sources))
                        t.sources = append(t.sources, cc.Source{Name: arg})
                case ".c":
                        t.symSearchOrder = append(t.symSearchOrder, len(t.sources))
                        t.sources = append(t.sources, cc.Source{Name: arg, DoNotCache: true})
                case ".json":
                        t.cdb = arg
                        return opt.Skip(nil)
                default:
                        return fmt.Errorf("unexpected file type: %s", arg)
                }

                return nil
        }); err != nil {
                switch x := err.(type) {
                case opt.Skip:
                        switch {
                        case t.compiledbValid: // -compiledb foo.json, create DB
                                cmd := []string(x)[1:]
                                if len(cmd) == 0 {
                                        return fmt.Errorf("missing command after -compiledb <file>")
                                }

                                return t.createCompileDB(cmd)
                        case t.cdb != "": // foo.json ..., use DB
                                if err := t.configure(); err != nil {
                                        return err
                                }

                                return t.useCompileDB(t.cdb, x)
                        }

                        return err
                default:
                        return err
                }
        }

        if t.version {
                gobin, err := exec.LookPath("go")
                var b []byte
                if err == nil {
                        var bin string
                        bin, err = exec.LookPath(os.Args[0])
                        if err == nil {
                                b, err = exec.Command(gobin, "version", "-m", bin).CombinedOutput()
                        }
                }
                if err == nil {
                        fmt.Fprintf(t.stdout, "%s", b)
                        return nil
                }

                fmt.Fprintf(t.stdout, "%s\n", Version)
                return nil
        }

        if t.scriptFn != "" {
                return t.scriptBuild(t.scriptFn)
        }

        if len(t.sources) == 0 {
                return fmt.Errorf("no input files specified")
        }

        if t.crtImportPath != "" {
                t.l = append(t.l, t.crtImportPath)
                t.symSearchOrder = append(t.symSearchOrder, -len(t.l))
                m := map[string]struct{}{}
                for _, v := range t.l {
                        v = strings.TrimSpace(v)
                        if _, ok := m[v]; !ok {
                                t.imported = append(t.imported, &imported{path: v})
                                m[v] = struct{}{}
                        }
                }
                t.imported[len(t.imported)-1].used = true // crt is always imported
        }

        if err := t.configure(); err != nil {
                return err
        }

        abi, err := cc.NewABI(t.goos, t.goarch)
        if err != nil {
                return err
        }
        abi.Types[cc.LongDouble] = abi.Types[cc.Double]

        var re *regexp.Regexp
        if t.ignoredIncludes != "" {
                if re, err = regexp.Compile(t.ignoredIncludes); err != nil {
                        return err
                }
        }

        t.cfg.ABI = abi
        t.cfg.ReplaceMacroFdZero = t.replaceFdZero
        t.cfg.ReplaceMacroTclDefaultDoubleRounding = t.replaceTclDefaultDoubleRounding
        t.cfg.ReplaceMacroTclIeeeDoubleRounding = t.replaceTclIeeeDoubleRounding
        t.cfg.Config3.IgnoreInclude = re
        t.cfg.Config3.NoFieldAndBitfieldOverlap = true
        t.cfg.Config3.PreserveWhiteSpace = t.saveConfig == ""
        t.cfg.Config3.UnsignedEnums = true

        if t.mingw = detectMingw(t.hostPredefined); t.mingw {
                t.windows = true
        }
        if t.nostdinc {
                t.hostIncludes = nil
                t.hostSysIncludes = nil
        }
        var sources []cc.Source
        if t.hostPredefined != "" {
                sources = append(sources, cc.Source{Name: "<predefined>", Value: t.hostPredefined})
        }
        sources = append(sources, cc.Source{Name: "<builtin>", Value: builtin})
        if len(t.D) != 0 {
                var a []string
                for _, v := range t.D {
                        if i := strings.IndexByte(v, '='); i > 0 {
                                a = append(a, fmt.Sprintf("#define %s %s", v[:i], v[i+1:]))
                                continue
                        }

                        a = append(a, fmt.Sprintf("#define %s 1", v))
                }
                a = append(a, "\n")
                sources = append(sources, cc.Source{Name: "<defines>", Value: strings.Join(a, "\n"), DoNotCache: true})
        }
        if len(t.U) != 0 {
                var a []string
                for _, v := range t.U {
                        a = append(a, fmt.Sprintf("#undef %s", v))
                }
                a = append(a, "\n")
                sources = append(sources, cc.Source{Name: "<undefines>", Value: strings.Join(a, "\n"), DoNotCache: true})
        }

        // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/c99.html
        //
        // Headers whose names are enclosed in double-quotes ( "" ) shall be
        // searched for first in the directory of the file with the #include
        // line, then in directories named in -I options, and last in the usual
        // places
        includePaths := append([]string{"@"}, t.I...)
        includePaths = append(includePaths, t.hostIncludes...)
        includePaths = append(includePaths, t.hostSysIncludes...)
        // For headers whose names are enclosed in angle brackets ( "<>" ), the
        // header shall be searched for only in directories named in -I options
        // and then in the usual places.
        sysIncludePaths := append(t.I, t.hostSysIncludes...)
        if t.traceTranslationUnits {
                fmt.Printf("target: %s/%s\n", t.goos, t.goarch)
                if t.hostConfigCmd != "" {
                        fmt.Printf("host config cmd: %s\n", t.hostConfigCmd)
                }
        }
        for i, v := range t.sources {
                tuSources := append(sources, v)
                out := t.stdout
                if t.saveConfig != "" {
                        out = io.Discard
                        t.E = true
                }
                if t.E {
                        t.cfg.PreprocessOnly = true
                        if err := cc.Preprocess(t.cfg, includePaths, sysIncludePaths, tuSources, out); err != nil {
                                return err
                        }
                        memGuard(i, t.isScripted)
                        continue
                }

                var t0 time.Time
                if t.traceTranslationUnits {
                        fmt.Printf("C front end %d/%d: %s ... ", i+1, len(t.sources), v.Name)
                        t0 = time.Now()
                }
                ast, err := cc.Translate(t.cfg, includePaths, sysIncludePaths, tuSources)
                if err != nil {
                        return err
                }

                if t.traceTranslationUnits {
                        fmt.Println(time.Since(t0))
                }
                t.asts = append(t.asts, ast)
                memGuard(i, t.isScripted)
        }
        if t.E || t.isScripted {
                return nil
        }

        return t.link()
}

func (t *Task) configure() (err error) {
        if t.configured {
                return nil
        }

        type jsonConfig struct {
                Predefined      string
                IncludePaths    []string
                SysIncludePaths []string
                OS              string
                Arch            string
        }

        t.configured = true
        if t.loadConfig != "" {
                path := filepath.Join(t.loadConfig, "config.json")
                // trc("%p: LOAD_CONFIG(%s)", t, path)
                b, err := ioutil.ReadFile(path)
                if err != nil {
                        return err
                }

                loadConfig := &jsonConfig{}
                if err := json.Unmarshal(b, loadConfig); err != nil {
                        return err
                }

                t.goos = loadConfig.OS
                t.goarch = loadConfig.Arch
                for _, v := range loadConfig.IncludePaths {
                        t.hostIncludes = append(t.hostIncludes, filepath.Join(t.loadConfig, v))
                }
                for _, v := range loadConfig.SysIncludePaths {
                        t.hostSysIncludes = append(t.hostSysIncludes, filepath.Join(t.loadConfig, v))
                }
                t.hostPredefined = loadConfig.Predefined
                return nil
        }

        hostConfigOpts := strings.Split(t.hostConfigOpts, ",")
        if t.hostConfigOpts == "" {
                hostConfigOpts = nil
        }
        if t.hostPredefined, t.hostIncludes, t.hostSysIncludes, err = cc.HostConfig(t.hostConfigCmd, hostConfigOpts...); err != nil {
                return err
        }

        if t.saveConfig != "" && !t.configSaved {
                t.configSaved = true
                // trc("%p: SAVE_CONFIG(%s)", t, t.saveConfig)
                cfg := &jsonConfig{
                        Predefined:      t.hostPredefined,
                        IncludePaths:    t.hostIncludes,
                        SysIncludePaths: t.hostSysIncludes,
                        OS:              t.goos,
                        Arch:            t.goarch,
                }
                b, err := json.Marshal(cfg)
                if err != nil {
                        return err
                }

                full := filepath.Join(t.saveConfig, "config.json")
                if err := os.MkdirAll(t.saveConfig, 0700); err != nil {
                        return err
                }

                if err := ioutil.WriteFile(full, b, 0600); err != nil {
                        return err
                }
        }

        return nil
}

func (t *Task) setLookPaths() (err error) {
        if t.ccLookPath, err = exec.LookPath(t.cc); err != nil {
                return err
        }

        t.arLookPath, err = exec.LookPath(t.ar)
        return err
}

func (t *Task) link() (err error) {
        if len(t.asts) == 0 {
                return fmt.Errorf("no objects to link")
        }

        if t.o == "" {
                t.o = fmt.Sprintf("a_%s_%s.go", t.goos, t.goarch)
        }
        dir := filepath.Dir(t.o)
        t.capif = filepath.Join(dir, fmt.Sprintf("capi_%s_%s.go", t.goos, t.goarch))
        f, err2 := os.Create(t.o)
        if err2 != nil {
                return err2
        }

        defer func() {
                if e := f.Close(); e != nil && err == nil {
                        err = e
                        return
                }

                if out, e := exec.Command("gofmt", "-r", "(x) -> x", "-l", "-s", "-w", t.o).CombinedOutput(); e != nil && err == nil {
                        err = fmt.Errorf(strings.Join([]string{string(out), e.Error()}, ": "))
                }
                if out, e := exec.Command("gofmt", "-l", "-s", "-w", t.o).CombinedOutput(); e != nil && err == nil {
                        err = fmt.Errorf(strings.Join([]string{string(out), e.Error()}, ": "))
                }
        }()

        w := bufio.NewWriter(f)

        defer func() {
                if e := w.Flush(); e != nil && err == nil {
                        err = e
                }
        }()

        t.out = w
        p, err := newProject(t)
        if err != nil {
                return err
        }

        return p.main()
}

func (t *Task) scriptBuild(fn string) error {
        f, err := os.Open(fn)
        if err != nil {
                return err
        }

        defer f.Close()

        r := csv.NewReader(f)
        r.Comment = '#'
        r.FieldsPerRecord = -1
        r.TrimLeadingSpace = true
        script, err := r.ReadAll()
        if err != nil {
                return err
        }

        return t.scriptBuild2(script)
}

func (t *Task) scriptBuild2(script [][]string) error {
        var ldir string
        ccgo := []string{t.args[0]}
        for i, line := range script {
                dir := line[0]
                args := line[1:]
                for _, v := range args {
                        if strings.HasSuffix(v, ".c") || strings.HasSuffix(v, ".h") {
                                v = filepath.Join(dir, v)
                                t.symSearchOrder = append(t.symSearchOrder, len(t.sources))
                                t.sources = append(t.sources, cc.Source{Name: v})
                        }
                }
                cmd := append(ccgo, args...)
                if t.traceTranslationUnits {
                        if dir != ldir {
                                fmt.Println(dir)
                                ldir = dir
                        }
                        fmt.Printf("%s\n", cmd)
                }
                t2 := NewTask(append(ccgo, args...), t.stdout, t.stderr)
                t2.cfg.IncludeFileHandler = t.cfg.IncludeFileHandler
                t2.cfg.SharedFunctionDefinitions = t.cfg.SharedFunctionDefinitions
                t2.configSaved = t.configSaved
                t2.configured = t.configured
                t2.hostIncludes = t.hostIncludes
                t2.hostPredefined = t.hostPredefined
                t2.hostSysIncludes = t.hostSysIncludes
                t2.includedFiles = t.includedFiles
                t2.isScripted = true
                t2.loadConfig = t.loadConfig
                t2.replaceFdZero = t.replaceFdZero
                t2.replaceTclDefaultDoubleRounding = t.replaceTclDefaultDoubleRounding
                t2.replaceTclIeeeDoubleRounding = t.replaceTclIeeeDoubleRounding
                t2.saveConfig = t.saveConfig
                if err := inDir(dir, t2.Main); err != nil {
                        return err
                }

                t.asts = append(t.asts, t2.asts...)
                if i == 0 {
                        t.cfg = t2.cfg
                }
        }
        if t.crtImportPath != "" {
                t.l = append(t.l, t.crtImportPath)
                t.symSearchOrder = append(t.symSearchOrder, -len(t.l))
                m := map[string]struct{}{}
                for _, v := range t.l {
                        v = strings.TrimSpace(v)
                        if _, ok := m[v]; !ok {
                                t.imported = append(t.imported, &imported{path: v})
                                m[v] = struct{}{}
                        }
                }
                t.imported[len(t.imported)-1].used = true // crt is always imported
        }
        if t.saveConfig != "" {
                return nil
        }

        return t.link()
}

type cdb struct {
        items       []*cdbItem
        outputIndex map[string][]*cdbItem
}

func (db *cdb) find(obj map[string]*cdbItem, nm string, ver, seqLimit int, path []string, cc, ar string, ignored map[string]struct{}) error {
        // trc("%v: nm %q ver %v seqLimit %v path %q cc %q ar %q", origin(1), nm, ver, seqLimit, path, cc, ar)
        var item *cdbItem
        var k string
        switch {
        case ver < 0:
                // find highest ver with .seq < seqLimit
                for i, v := range db.outputIndex[nm] {
                        if v.seq >= seqLimit {
                                break
                        }

                        item = v
                        ver = i
                }
                if item == nil {
                        ver = -1
                        for _, v := range db.items {
                                if seqLimit >= 0 && v.seq >= seqLimit {
                                        break
                                }

                                if filepath.Base(v.Output) == filepath.Base(nm) {
                                        item = v
                                        ver = v.ver
                                        break
                                }
                        }
                }

                k = fmt.Sprintf("%s#%d", nm, ver)
        default:
                // match ver exactly
                k = fmt.Sprintf("%s#%d", nm, ver)
                if obj[k] != nil {
                        return nil
                }

                items := db.outputIndex[nm]
                switch {
                case ver < len(items):
                        panic(todo("", nm, ver, seqLimit))
                default:
                        n := -1
                        for _, v := range db.items {
                                if seqLimit >= 0 && v.seq >= seqLimit {
                                        break
                                }

                                if filepath.Base(v.Output) == filepath.Base(nm) {
                                        n++
                                        if n == ver {
                                                item = v
                                                break
                                        }
                                }
                        }
                }
        }
        if item == nil {
                for k := range ignored {
                        if k == nm || strings.HasSuffix(nm, k) {
                                return nil
                        }
                }

                return fmt.Errorf("not found in compile DB: %s (max seq %d), path %v", k, seqLimit, path)
        }

        if obj[k] != nil {
                return nil
        }

        obj[k] = item
        var errs []string
        for _, v := range item.sources(cc, ar) {
                if err := db.find(obj, v, -1, item.seq, append(path, nm), cc, ar, ignored); err != nil {
                        errs = append(errs, err.Error())
                }
        }
        if len(errs) != 0 {
                sort.Strings(errs)
                w := 0
                for _, v := range errs {
                        if w == 0 || w > 0 && v != errs[w-1] {
                                errs[w] = v
                                w++
                        }
                }
                errs = errs[:w]
                return fmt.Errorf("%s", strings.Join(errs, "\n"))
        }

        return nil
}

func suffixNum(s string, dflt int) (string, int) {
        x := strings.LastIndexByte(s, '#')
        if x < 0 {
                return s, dflt
        }

        // foo#42
        // 012345
        // x == 3
        num := s[x+1:]
        n, err := strconv.ParseUint(num, 10, 32)
        if err != nil {
                return s, dflt
        }

        return s[:x], int(n)
}

func (t *Task) useCompileDB(fn string, args []string) error {
        if err := t.setLookPaths(); err != nil {
                return err
        }

        var cdb cdb
        f, err := os.Open(fn)
        if err != nil {
                return err
        }

        de := json.NewDecoder(f)
        err = de.Decode(&cdb.items)
        f.Close()
        if err != nil {
                return err
        }

        cdb.outputIndex = map[string][]*cdbItem{}
        for i, v := range cdb.items {
                v.seq = i
                if len(v.Arguments) == 0 {
                        if len(v.Command) == 0 {
                                return fmt.Errorf("either arguments or command is required: %+v", v)
                        }

                        if v.Arguments, err = shellquote.Split(v.Command); err != nil {
                                return err
                        }
                }

                k := v.output(t.ccLookPath, t.arLookPath)
                a := cdb.outputIndex[k]
                v.ver = len(a)
                cdb.outputIndex[k] = append(a, v)
        }
        obj := map[string]*cdbItem{}
        notFound := false
        for _, v := range args {
                v, ver := suffixNum(v, 0)
                if err := cdb.find(obj, v, ver, -1, nil, t.ccLookPath, t.arLookPath, t.ignoredObjects); err != nil {
                        notFound = true
                        fmt.Fprintln(os.Stderr, err)
                }
        }
        if notFound {
                var a []string
                for k, v := range cdb.outputIndex {
                        for _, w := range v {
                                a = append(a, fmt.Sprintf("%5d %s", w.seq, k))
                        }
                }
                sort.Strings(a)
                fmt.Fprintf(os.Stderr, "compile DB index:\n\t%s\n", strings.Join(a, "\n\t"))
        }

        var a []string
        for k := range obj {
                a = append(a, k)
        }
        sort.Strings(a)
        return t.cdbBuild(obj, a)
}

func (t *Task) cdbBuild(obj map[string]*cdbItem, list []string) error {
        var script [][]string
        for _, nm := range list {
                it := obj[nm]
                if !strings.HasSuffix(it.Output, ".o") || it.Arguments[0] != t.cc {
                        continue
                }

                args, err := it.ccgoArgs(t.cc)
                if err != nil {
                        return err
                }

                for _, v := range t.D {
                        args = append(args, "-D"+v)
                }
                for _, v := range t.U {
                        args = append(args, "-U"+v)
                }

                line := append([]string{it.Directory}, args...)
                script = append(script, line)
        }
        return t.scriptBuild2(script)
}

func (t *Task) createCompileDB(command []string) (rerr error) {
        if err := t.setLookPaths(); err != nil {
                return err
        }

        cwd, err := os.Getwd()
        if err != nil {
                return err
        }

        f, err := os.Create(t.compiledb)
        if err != nil {
                return err
        }

        defer func() {
                if err := f.Close(); err != nil && rerr == nil {
                        rerr = err
                }
        }()

        cwr := newCDBWriter(f)

        defer func() {
                if err := cwr.finish(); err != nil && rerr == nil {
                        rerr = err
                }
        }()

        var cmd *exec.Cmd
        var parser func(s string) ([]string, error)
out:
        switch t.goos {
        case "darwin", "freebsd", "netbsd":
                switch command[0] {
                case "make", "gmake":
                        // ok
                default:
                        return fmt.Errorf("usupported build command: %s", command[0])
                }

                sh, err := exec.LookPath("sh")
                if err != nil {
                        return err
                }

                command = append([]string{sh, "-c"}, join(" ", command[0], "SHELL='sh -x'", command[1:]))
                cmd = exec.Command(command[0], command[1:]...)
                parser = makeXParser
        case "openbsd":
                switch command[0] {
                case "make", "gmake":
                        // ok
                default:
                        return fmt.Errorf("usupported build command: %s", command[0])
                }

                sh, err := exec.LookPath("sh")
                if err != nil {
                        return err
                }

                command = append([]string{sh, "-c"}, join(" ", command[0], "SHELL='sh -x'", command[1:]))
                cmd = exec.Command(command[0], command[1:]...)
                parser = makeXParser2
        case "windows":
                if command[0] != "make" && command[0] != "make.exe" {
                        return fmt.Errorf("usupported build command: %s", command[0])
                }

                switch s := runtime.GOOS; s {
                case "windows":
                        argv := append([]string{"-d"}, command[1:]...)
                        if !strings.HasSuffix(command[0], ".exe") {
                                command[0] += ".exe"
                        }
                        cmd = exec.Command(command[0], argv...)
                        parser = makeDParser
                        break out
                case "linux":
                        // ok
                default:
                        return fmt.Errorf("usupported cross compile host: %s", s)
                }

                fallthrough
        default:
                strace, err := exec.LookPath("strace")
                if err != nil {
                        return err
                }

                argv := append([]string{"-f", "-s1000000", "-e", "trace=execve"}, command...)
                cmd = exec.Command(strace, argv...)
                parser = straceParser
        }
        cmd.Env = append(os.Environ(), "LC_ALL=C")
        cw := t.newCdbMakeWriter(cwr, cwd, parser)
        switch {
        case t.verboseCompiledb:
                cmd.Stdout = io.MultiWriter(cw, os.Stdout)
        default:
                cmd.Stdout = cw
        }
        cmd.Stderr = cmd.Stdout
        if dmesgs {
                dmesg("%v: %v", origin(1), cmd.Args)
        }
        if err := cmd.Run(); err != nil {
                if dmesgs {
                        dmesg("%v: cmd.Run: %v", origin(1), err)
                }
                return err
        }

        return cw.err
}

func makeDParser(s string) ([]string, error) {
        const prefix = "CreateProcess("
        if !strings.HasPrefix(s, prefix) {
                return nil, nil
        }

        // s: `CreateProcess(C:\Program Files\CodeBlocks\MinGW\bin\gcc.exe,gcc -O3 -Wall -c -o compress.o compress.c,...)`
        s = s[len(prefix):]
        // s: `C:\Program Files\CodeBlocks\MinGW\bin\gcc.exe,gcc -O3 -Wall -c -o compress.o compress.c,...)`
        x := strings.IndexByte(s, ',')
        if x < 0 {
                return nil, nil
        }

        cmd := s[:x]
        // cmd: `C:\Program Files\CodeBlocks\MinGW\bin\gcc.exe`

        s = s[x+1:]
        // s: `gcc -O3 -Wall -c -o compress.o compress.c,...)`
        if x = strings.LastIndexByte(s, ','); x < 0 {
                return nil, nil
        }

        s = s[:x]
        // s: `gcc -O3 -Wall -c -o compress.o compress.c`
        a, err := shellquote.Split(strings.TrimSpace(s))
        if err != nil || len(a) == 0 {
                return nil, err
        }

        return append([]string{cmd}, a[1:]...), nil
}

func isCreateArchive(s string) bool {
        // ar modifiers may be in any order so sort characters in s before checking.
        // This turns eg `rc` into `cr`.
        b := []byte(s)
        sort.Slice(b, func(i, j int) bool { return b[i] < b[j] })
        switch string(b) {
        case "cq", "cr", "crs", "cru", "r":
                return true
        }
        return false
}

func hasPlusPrefix(s string) (n int, r string) {
        for strings.HasPrefix(s, "+") {
                n++
                s = s[1:]
        }
        return n, s
}

func makeXParser(s string) (r []string, err error) {
        switch {
        case strings.HasPrefix(s, "libtool: link: ar "):
                s = s[len("libtool: link:"):]
        case strings.HasPrefix(s, "libtool: compile: "):
                s = s[len("libtool: compile:"):]
                for strings.HasPrefix(s, "  ") {
                        s = s[1:]
                }
        default:
                var n int
                if n, s = hasPlusPrefix(s); n == 0 {
                        return nil, nil
                }
        }

        if !strings.HasPrefix(s, " ") {
                return nil, nil
        }

        s = s[1:]
        if dmesgs {
                dmesg("%v: source line `%s`, caller %v:", origin(1), s, origin(2))
        }
        r, err = shellquote.Split(s)
        if dmesgs {
                dmesg("%v: shellquote.Split -> %v %[2]q, %v", origin(1), r, err)
        }
        if err != nil {
                if strings.Contains(err.Error(), "Unterminated single-quoted string") {
                        return nil, nil // ignore
                }
        }
        if len(r) != 0 && filepath.Base(r[0]) == "libtool" {
                r[0] = "libtool"
        }
        return r, err
}

func makeXParser2(s string) (r []string, err error) {
        s = strings.TrimSpace(s)
        switch {
        case strings.HasPrefix(s, "libtool: link: ar "):
                s = s[len("libtool: link:"):]
        case strings.HasPrefix(s, "libtool: compile: "):
                s = s[len("libtool: compile:"):]
                for strings.HasPrefix(s, "  ") {
                        s = s[1:]
                }
        default:
                var n int
                if n, s = hasPlusPrefix(s); n != 0 {
                        return nil, nil
                }
        }

        if dmesgs {
                dmesg("%v: source line `%s`, caller %v:", origin(1), s, origin(2))
        }
        r, err = shellquote.Split(s)
        if dmesgs {
                dmesg("%v: shellquote.Split -> %v %[2]q, %v", origin(1), r, err)
        }
        if err != nil {
                if strings.Contains(err.Error(), "Unterminated single-quoted string") {
                        return nil, nil // ignore
                }
        }
        if len(r) != 0 && filepath.Base(r[0]) == "libtool" {
                r[0] = "libtool"
        }
        return r, err
}

func straceParser(s string) ([]string, error) {
        prefix := "execve("
        if strings.HasPrefix(s, "[pid ") {
                s = strings.TrimSpace(s[strings.IndexByte(s, ']')+1:])
        }
        if !strings.HasPrefix(s, prefix) || !strings.HasSuffix(s, ") = 0") {
                return nil, nil
        }

        // s: `execve("/usr/bin/ar", ["ar", "cr", "libtcl8.6.a", "regcomp.o", ... "bn_s_mp_sqr.o", "bn_s_mp_sub.o"], 0x55e6bbf49648 /* 60 vars */) = 0`
        s = s[len(prefix):]
        // s: `"/usr/bin/ar", ["ar", "cr", "libtcl8.6.a", "regcomp.o", ... "bn_s_mp_sqr.o", "bn_s_mp_sub.o"], 0x55e6bbf49648 /* 60 vars */) = 0`
        a := strings.SplitN(s, ", [", 2)
        // a[0]: `"/usr/bin/ar"`, a[1]: `"ar", "cr", "libtcl8.6.a", "regcomp.o", ... "bn_s_mp_sqr.o", "bn_s_mp_sub.o"], 0x55e6bbf49648 /* 60 vars */) = 0`
        args := a[1]
        // args: `"ar", "cr", "libtcl8.6.a", "regcomp.o", ... "bn_s_mp_sqr.o", "bn_s_mp_sub.o"], 0x55e6bbf49648 /* 60 vars */) = 0`
        args = args[:strings.LastIndex(args, "], ")]
        // args: `"ar", "cr", "libtcl8.6.a", "regcomp.o", ... "bn_s_mp_sqr.o", "bn_s_mp_sub.o"`
        argv, err := shellquote.Split(args)
        if err != nil {
                return nil, err
        }

        words, err := shellquote.Split(a[0])
        if err != nil {
                return nil, err
        }

        argv[0] = words[0]
        for i, v := range argv {
                if strings.HasSuffix(v, ",") {
                        v = v[:len(v)-1]
                }
                if v2, err := strconv.Unquote(`"` + v + `"`); err == nil {
                        v = v2
                }
                argv[i] = v
        }

        return argv, nil
}

type cdbItem struct {
        Arguments []string `json:"arguments"`
        Command   string   `json:"command,omitempty"`
        Directory string   `json:"directory"`
        File      string   `json:"file"`
        Output    string   `json:"output,omitempty"`

        seq int
        ver int
}

func (it *cdbItem) cmpString() string { return fmt.Sprint(*it) }

func (it *cdbItem) ccgoArgs(cc string) (r []string, err error) {
        switch it.Arguments[0] {
        case cc:
                set := opt.NewSet()
                set.Arg("D", true, func(opt, arg string) error { r = append(r, "-D"+arg); return nil })
                set.Arg("I", true, func(opt, arg string) error { r = append(r, "-I"+arg); return nil })
                set.Arg("MF", true, func(opt, arg string) error { return nil })
                set.Arg("MT", true, func(opt, arg string) error { return nil })
                set.Arg("O", true, func(opt, arg string) error { return nil })
                set.Arg("U", true, func(opt, arg string) error { r = append(r, "-U"+arg); return nil })
                set.Arg("o", true, func(opt, arg string) error { return nil })
                set.Arg("std", true, func(opt, arg string) error { return nil })
                set.Opt("MD", func(opt string) error { return nil })
                set.Opt("MMD", func(opt string) error { return nil })
                set.Opt("MP", func(opt string) error { return nil })
                set.Opt("ansi", func(opt string) error { return nil })
                set.Opt("c", func(opt string) error { return nil })
                set.Opt("g", func(opt string) error { return nil })
                set.Opt("pedantic", func(opt string) error { return nil })
                set.Opt("pipe", func(opt string) error { return nil })
                set.Opt("pthread", func(opt string) error { return nil })
                set.Opt("s", func(opt string) error { return nil })
                set.Opt("w", func(opt string) error { return nil })
                if err := set.Parse(it.Arguments[1:], func(arg string) error {
                        switch {
                        case strings.HasSuffix(arg, ".c"):
                                r = append(r, arg)
                        case

                                strings.HasPrefix(arg, "-W"),
                                strings.HasPrefix(arg, "-f"),
                                strings.HasPrefix(arg, "-m"):

                                // nop
                        case strings.HasPrefix(arg, ">"):
                                return opt.Skip(nil)
                        default:
                                return fmt.Errorf("unknown/unsupported CC option: %s", arg)
                        }

                        return nil
                }); err != nil {
                        switch err.(type) {
                        case opt.Skip:
                                // ok
                        default:
                                return nil, err
                        }
                }

                return r, nil
        default:
                return nil, fmt.Errorf("command not supported: %q", it.Arguments[0])
        }
}

func (it *cdbItem) output(cc, ar string) (r string) {
        if it.Output != "" {
                return it.Output
        }

        if len(it.Arguments) == 0 {
                return ""
        }

        switch it.Arguments[0] {
        case cc:
                for i, v := range it.Arguments {
                        if v == "-o" && i < len(it.Arguments)-1 {
                                it.Output = filepath.Join(it.Directory, it.Arguments[i+1])
                                break
                        }
                }
                if it.Output == "" && strings.HasSuffix(it.File, ".c") {
                        for _, v := range it.Arguments {
                                if v == "-c" {
                                        bn := filepath.Base(it.File)
                                        it.Output = filepath.Join(it.Directory, bn[:len(bn)-2]+".o")
                                        break
                                }
                        }
                }
        case ar:
                if isCreateArchive(it.Arguments[1]) {
                        it.Output = filepath.Join(it.Directory, it.Arguments[2])
                }
        case "libtool":
                for i, v := range it.Arguments {
                        if v == "-o" && i < len(it.Arguments)-1 {
                                it.Output = filepath.Join(it.Directory, it.Arguments[i+1])
                        }
                }
        }
        return it.Output
}

func (it *cdbItem) sources(cc, ar string) (r []string) {
        if len(it.Arguments) == 0 {
                return nil
        }

        switch arg0 := it.Arguments[0]; arg0 {
        case
                "libtool",
                ar,
                filepath.Base(ar),
                cc:

                var prev string
                for _, v := range it.Arguments {
                        switch prev {
                        case "-o", "-MT", "-MF":
                                // nop
                        default:
                                if strings.HasSuffix(v, ".o") {
                                        r = append(r, filepath.Join(it.Directory, v))
                                }
                        }
                        prev = v
                }
                return r
        default:
                panic(todo("cc: %q ar: %q it: %+v", cc, ar, it))
        }
}

type cdbMakeWriter struct {
        ar     string
        arBase string
        b      bytes.Buffer
        cc     string
        dir    string
        err    error
        it     cdbItem
        parser func(s string) ([]string, error)
        prefix string
        sc     *bufio.Scanner
        t      *Task
        w      *cdbWriter
}

func (t *Task) newCdbMakeWriter(w *cdbWriter, dir string, parser func(s string) ([]string, error)) *cdbMakeWriter {
        const sz = 1 << 16
        r := &cdbMakeWriter{
                ar:     t.arLookPath,
                arBase: filepath.Base(t.arLookPath),
                cc:     t.ccLookPath,
                dir:    dir,
                parser: parser,
                t:      t,
                w:      w,
        }
        r.sc = bufio.NewScanner(&r.b)
        r.sc.Buffer(make([]byte, sz), sz)
        return r
}

func (w *cdbMakeWriter) fail(err error) {
        if w.err == nil {
                w.err = fmt.Errorf("%v (%v)", err, origin(2))
        }
}

func (w *cdbMakeWriter) Write(b []byte) (int, error) {
        w.b.Write(b)
        for bytes.Contains(w.b.Bytes(), []byte{'\n'}) {
                if !w.sc.Scan() {
                        panic(todo("internal error"))
                }

                s := w.sc.Text()
                if strings.HasSuffix(s, "\\") {
                        w.prefix += s[:len(s)-1]
                        continue
                }

                s = w.prefix + s
                w.prefix = ""
                s = strings.TrimSpace(s)
                if edx := strings.Index(s, "Entering directory"); edx >= 0 {
                        s = s[edx+len("Entering directory"):]
                        s = strings.TrimSpace(s)
                        if len(s) == 0 {
                                continue
                        }

                        if (s[0] == '\'' || s[0] == '`') && s[len(s)-1] == '\'' {
                                s = s[1:]
                                if len(s) == 0 {
                                        continue
                                }

                                s = s[:len(s)-1]
                        }
                        s = `"` + s + `"`
                        dir, err := strconv.Unquote(s)
                        if err != nil {
                                w.fail(err)
                                continue
                        }

                        dir = filepath.Clean(dir)
                        if dir == w.dir {
                                continue
                        }

                        w.dir = dir
                        fmt.Printf("cd %s\n", dir)
                        continue
                }

                if dmesgs {
                        dmesg("%v: source line `%s`", origin(1), s)
                }
                args, err := w.parser(s)
                if dmesgs {
                        dmesg("%v: parser -> %v %[2]q, %v", origin(1), args, err)
                }
                if err != nil {
                        w.fail(err)
                        continue
                }

                if len(args) == 0 {
                        continue
                }

                // TODO: change so eg handleGCC returns []cdbItem, skip if none.

                w.it = cdbItem{}

                err = nil
                switch args[0] {
                case w.cc:
                        if w.t.verboseCompiledb {
                                fmt.Printf("source line: %q\n", s)
                        }
                        fmt.Printf("CCGO CC: %q\n", args)
                        err = w.handleGCC(args)
                case w.ar:
                        fallthrough
                case w.arBase:
                        if isCreateArchive(args[1]) {
                                if w.t.verboseCompiledb {
                                        fmt.Printf("source line: %q\n", s)
                                }
                                fmt.Printf("CCGO AR: %q\n", args)
                                err = w.handleAR(args)
                        }
                case "libtool":
                        if w.t.verboseCompiledb {
                                fmt.Printf("source line: %q\n", s)
                        }
                        fmt.Printf("CCGO LIBTOOL: %q\n", args)
                        err = w.handleLibtool(args)
                }
                if err != nil {
                        w.fail(err)
                        continue
                }

                if w.it.Output != "" {
                        w.w.add(w.it)
                }
        }
        return len(b), nil
}

func (w *cdbMakeWriter) handleLibtool(args []string) error {
        w.it = cdbItem{
                Arguments: args,
                Directory: w.dir,
        }
        for i, v := range args {
                switch {
                case v == "-o" && i < len(args)-1:
                        w.it.Output = filepath.Join(w.dir, args[i+1])
                }
        }
        w.it.output(w.cc, w.ar)
        return nil
}

func (w *cdbMakeWriter) handleAR(args []string) error {
        w.it = cdbItem{
                Arguments: args,
                Directory: w.dir,
        }
        // TODO: assumes isCreateArchive has already been checked
        w.it.Output = filepath.Join(w.dir, args[2])
        return nil
}

func (w *cdbMakeWriter) handleGCC(args []string) error {
        w.it = cdbItem{
                Arguments: args,
                Directory: w.dir,
        }
        for i, v := range args {
                switch {
                case v == "-o" && i < len(args)-1:
                        w.it.Output = filepath.Join(w.dir, args[i+1])
                case strings.HasSuffix(v, ".c"):
                        if w.it.File != "" {
                                return fmt.Errorf("multiple .c files: %s", v)
                        }

                        w.it.File = filepath.Clean(v)
                }
        }
        w.it.output(w.cc, w.ar)
        return nil
}

type cdbWriter struct {
        w     *bufio.Writer
        items []cdbItem
}

func newCDBWriter(w io.Writer) *cdbWriter {
        return &cdbWriter{w: bufio.NewWriter(w)}
}

func (w *cdbWriter) add(item cdbItem) {
        w.items = append(w.items, item)
}

func (w *cdbWriter) finish() error {
        enc := json.NewEncoder(w.w)
        enc.SetIndent("", "    ")
        if err := enc.Encode(w.items); err != nil {
                return err
        }
        return w.w.Flush()
}

func join(sep string, a ...interface{}) string {
        var b []string
        for _, v := range a {
                switch x := v.(type) {
                case string:
                        b = append(b, x)
                case []string:
                        b = append(b, x...)
                default:
                        panic(todo("internal error: %T", x))
                }
        }
        return strings.Join(b, sep)
}

func inDir(dir string, f func() error) (err error) {
        var cwd string
        if cwd, err = os.Getwd(); err != nil {
                return err
        }

        defer func() {
                if err2 := os.Chdir(cwd); err2 != nil {
                        err = err2
                }
        }()

        if err = os.Chdir(dir); err != nil {
                return err
        }

        return f()
}

func detectMingw(s string) bool {
        return strings.Contains(s, "#define __MINGW")
}

func memGuard(i int, force bool) {
        if totalRam == 0 || totalRam > 64e9 {
                return
        }

        var ms runtime.MemStats
        runtime.ReadMemStats(&ms)
        switch {
        case ms.Alloc < totalRam/2:
                return
        case ms.Alloc < (8*totalRam)/10:
                if force {
                        break
                }

                switch {
                case totalRam < 1e9:
                        // ok
                case totalRam < 16e9:
                        if i&1 == 1 {
                                return
                        }
                default:
                        if i&3 != 3 {
                                return
                        }
                }
        }

        debug.FreeOSMemory()
}