gtsocial-umbx

ccgo.go (56560B)

---

 // 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()
 }