source: code/trunk/vendor/modernc.org/cc/v3/cc.go@ 824

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

//TODO https://todo.sr.ht/~mcf/cc-issues/34
//TODO http://mcpp.sourceforge.net/ "Provides a validation suite to test C/C++ preprocessor's conformance and quality comprehensively."

//go:generate rm -f lexer.go
//go:generate golex -o lexer.go lexer.l

//go:generate rm -f ast.go
//go:generate yy -o /dev/null -position -astImport "\"fmt\"\n\n\"modernc.org/token\"" -prettyString PrettyString -kind Case -noListKind -noPrivateHelpers -forceOptPos parser.yy

//go:generate stringer -output stringer.go -linecomment -type=Kind,Linkage

//go:generate sh -c "go test -run ^Example |fe"

// Package cc is a C99 compiler front end (Work in progress).
//
// Installation
//
// To install/update cc/v3 invoke:
//
//     $ go get [-u] modernc.org/cc/v3
//
// Online documentation
//
// See https://godoc.org/modernc.org/cc/v3.
//
// Status
//
// Most of the functionality is now working.
//
// Supported platforms
//
// The code is known to work on Darwin, Linux and Windows, but the supported
// features may vary.
//
// Links
//
// Referenced from elsewhere:
//
//  [0]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf
//  [1]: https://www.spinellis.gr/blog/20060626/cpp.algo.pdf
//  [2]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
//  [3]: http://gallium.inria.fr/~fpottier/publis/jourdan-fpottier-2016.pdf
//  [4]: https://gcc.gnu.org/onlinedocs/gcc-8.3.0/gcc/Attribute-Syntax.html#Attribute-Syntax
package cc // import "modernc.org/cc/v3"

import (
        "fmt"
        goscanner "go/scanner"
        gotoken "go/token"
        "hash/maphash"
        "io"
        "math"
        "os"
        "os/exec"
        "reflect"
        "regexp"
        "runtime"
        "sort"
        "strconv"
        "strings"
        "sync"
        "sync/atomic"

        "modernc.org/strutil"
        "modernc.org/token"
)

const (
        scopeParent StringID = -iota - 1
        scopeSkip
)

var (
        _ Pragma = (*pragma)(nil)

        cache       = newPPCache()
        dict        = newDictionary()
        dictStrings [math.MaxUint8 + 1]string
        noPos       token.Position

        debugIncludePaths bool
        debugWorkingDir   bool
        isTesting         bool
        isTestingMingw    bool

        idPtrdiffT = dict.sid("ptrdiff_t")
        idSizeT    = dict.sid("size_t")
        idWCharT   = dict.sid("wchar_t")

        token4Pool = sync.Pool{New: func() interface{} { r := make([]token4, 0); return &r }} //DONE benchmrk tuned capacity
        tokenPool  = sync.Pool{New: func() interface{} { r := make([]Token, 0); return &r }}  //DONE benchmrk tuned capacity

        printHooks = strutil.PrettyPrintHooks{
                reflect.TypeOf(Token{}): func(f strutil.Formatter, v interface{}, prefix, suffix string) {
                        t := v.(Token)
                        if (t == Token{}) {
                                return
                        }

                        f.Format(prefix)
                        r := t.Rune
                        if p := t.Position(); p.IsValid() {
                                f.Format("%v: ", p)
                        }
                        s := tokName(r)
                        if x := s[0]; x >= '0' && x <= '9' {
                                s = strconv.QuoteRune(r)
                        }
                        f.Format("%s", s)
                        if s := t.Value.String(); len(s) != 0 {
                                f.Format(" %q", s)
                        }
                        f.Format(suffix)
                },
                reflect.TypeOf((*operand)(nil)): func(f strutil.Formatter, v interface{}, prefix, suffix string) {
                        op := v.(*operand)
                        f.Format(prefix)
                        f.Format("[%v %T(%[2]v)]", op.Type(), op.Value())
                        f.Format(suffix)
                },
        }
)

func todo(s string, args ...interface{}) string { //TODO-
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        pc, fn, fl, _ := runtime.Caller(1)
        f := runtime.FuncForPC(pc)
        var fns string
        if f != nil {
                fns = f.Name()
                if x := strings.LastIndex(fns, "."); x > 0 {
                        fns = fns[x+1:]
                }
        }
        r := fmt.Sprintf("%s:%d:%s: TODOTODO %s", fn, fl, fns, s) //TODOOK
        fmt.Fprintf(os.Stdout, "%s\n", r)
        os.Stdout.Sync()
        return r
}

func trc(s string, args ...interface{}) string { //TODO-
        switch {
        case s == "":
                s = fmt.Sprintf(strings.Repeat("%v ", len(args)), args...)
        default:
                s = fmt.Sprintf(s, args...)
        }
        pc, fn, fl, _ := runtime.Caller(1)
        f := runtime.FuncForPC(pc)
        var fns string
        if f != nil {
                fns = f.Name()
                if x := strings.LastIndex(fns, "."); x > 0 {
                        fns = fns[x+1:]
                }
        }
        r := fmt.Sprintf("%s:%d:%s: TRC %s", fn, fl, fns, s)
        fmt.Fprintf(os.Stdout, "%s\n", r)
        os.Stdout.Sync()
        return r
}

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

// String returns a StringID for a given value.
func String(s string) StringID {
        return dict.sid(s)
}

// Linkage represents identifier linkage.
//
// [0]6.2.2: An identifier declared in different scopes or in the same scope
// more than once can be made to refer to the same object or function by a
// process called linkage. There are three kinds of linkage: External,
// Internal, and None.
type Linkage int

// StorageClass determines storage duration.
//
// [0]6.2.4: An object has a storage duration that determines its lifetime.
// There are three storage durations: Static, Automatic, and Allocated.
type StorageClass int

// Pragma defines behavior of the object passed to Config.PragmaHandler.
type Pragma interface {
        Error(msg string, args ...interface{}) // Report error.
        MaxAligment() int                      // Returns the current maximum alignment. May return zero.
        MaxInitialAligment() int               // Support #pragma pack(). Returns the maximum alignment in effect at start. May return zero.
        PopMacro(string)
        PushMacro(string)
        SetAlignment(n int) // Support #pragma pack(n)
}

type pragma struct {
        tok cppToken
        c   *cpp
}

func (p *pragma) Error(msg string, args ...interface{}) { p.c.err(p.tok, msg, args...) }

func (p *pragma) MaxAligment() int { return p.c.ctx.maxAlign }

func (p *pragma) MaxInitialAligment() int { return p.c.ctx.maxAlign0 }

func (p *pragma) SetAlignment(n int) {
        if n <= 0 {
                p.Error("%T.SetAlignment(%d): invalid argument", p, n)
                return
        }

        p.c.ctx.maxAlign = n
}

func (p *pragma) PushMacro(nm string) {
        id := dict.sid(nm)
        if p.c.macroStack == nil {
                p.c.macroStack = map[StringID][]*Macro{}
        }
        if m := p.c.macros[id]; m != nil {
                p.c.macroStack[id] = append(p.c.macroStack[id], p.c.macros[id])
        }
}

func (p *pragma) PopMacro(nm string) {
        id := dict.sid(nm)
        a := p.c.macroStack[id]
        if n := len(a); n != 0 {
                p.c.macros[id] = a[n-1]
                p.c.macroStack[id] = a[:n-1]
        }
}

// PrettyString returns a formatted representation of things produced by this package.
func PrettyString(v interface{}) string {
        return strutil.PrettyString(v, "", "", printHooks)
}

// StringID is a process-unique string numeric identifier. Its zero value
// represents an empty string.
type StringID int32

// String implements fmt.Stringer.
func (n StringID) String() (r string) {
        if n < 256 {
                return dictStrings[byte(n)]
        }

        dict.mu.RLock()
        r = dict.strings[n]
        dict.mu.RUnlock()
        return r
}

// Node is implemented by Token and all AST nodes.
type Node interface {
        Position() token.Position
}

type noder struct{}

func (noder) Position() token.Position { panic(internalError()) }

// Scope maps identifiers to definitions.
type Scope map[StringID][]Node

func (s *Scope) new() (r Scope) {
        if *s == nil {
                *s = Scope{}
        }
        r = Scope{scopeParent: []Node{struct {
                noder
                Scope
        }{Scope: *s}}}
        return r
}

func (s *Scope) declare(nm StringID, n Node) {
        sc := *s
        if sc == nil {
                *s = map[StringID][]Node{nm: {n}}
                // t := ""
                // if x, ok := n.(*Declarator); ok && x.IsTypedefName {
                //      t = ", typedefname"
                // }
                // dbg("declared %s%s at %v in scope %p", nm, t, n.Position(), *s)
                return
        }

        switch x := n.(type) {
        case *Declarator, *StructDeclarator, *LabeledStatement, *BlockItem:
                // nop
        case *StructOrUnionSpecifier, *EnumSpecifier, *Enumerator:
                for {
                        if _, ok := sc[scopeSkip]; !ok {
                                break
                        }

                        sc = sc.Parent()
                }
        default:
                panic(todo("%T", x))
        }

        sc[nm] = append(sc[nm], n)
        // t := ""
        // if x, ok := n.(*Declarator); ok && x.IsTypedefName {
        //      t = ", typedefname"
        // }
        // dbg("declared %s%s at %v in scope %p", nm, t, n.Position(), sc)
}

// Parent returns s's outer scope, if any.
func (s Scope) Parent() Scope {
        if s == nil {
                return nil
        }

        if x, ok := s[scopeParent]; ok {
                return x[0].(struct {
                        noder
                        Scope
                }).Scope
        }

        return nil
}

func (s *Scope) typedef(nm StringID, tok Token) *Declarator {
        seq := tok.seq
        for s := *s; s != nil; s = s.Parent() {
                for _, v := range s[nm] {
                        switch x := v.(type) {
                        case *Declarator:
                                if !x.isVisible(seq) {
                                        continue
                                }

                                if x.IsTypedefName {
                                        return x
                                }

                                return nil
                        case *Enumerator:
                                return nil
                        case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator:
                                // nop
                        default:
                                panic(internalError())
                        }
                }
        }
        return nil
}

func (s *Scope) declarator(nm StringID, tok Token) *Declarator {
        seq := tok.seq
        for s := *s; s != nil; s = s.Parent() {
                defs := s[nm]
                for _, v := range defs {
                        switch x := v.(type) {
                        case *Declarator:
                                if !x.isVisible(seq) {
                                        continue
                                }

                                for _, v := range defs {
                                        if x, ok := v.(*Declarator); ok {
                                                t := x.Type()
                                                if t != nil && t.Kind() == Function {
                                                        if x.fnDef {
                                                                return x
                                                        }

                                                        continue
                                                }

                                                if t != nil && !x.Type().IsIncomplete() {
                                                        return x
                                                }
                                        }

                                }
                                return x
                        case *Enumerator:
                                return nil
                        case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator:
                                // nop
                        default:
                                panic(internalError())
                        }
                }
        }
        return nil
}

func (s *Scope) enumerator(nm StringID, tok Token) *Enumerator {
        seq := tok.seq
        for s := *s; s != nil; s = s.Parent() {
                for _, v := range s[nm] {
                        switch x := v.(type) {
                        case *Declarator:
                                if !x.isVisible(seq) {
                                        continue
                                }

                                return nil
                        case *Enumerator:
                                return x
                        case *EnumSpecifier, *StructOrUnionSpecifier, *StructDeclarator:
                                // nop
                        default:
                                panic(internalError())
                        }
                }
        }
        return nil
}

// Config3 amends behavior of translation phases 1 to 3.
type Config3 struct {
        // If IgnoreInclude is not nil, its MatchString method will be called by the
        // preprocessor with the argument any include directive expands to. If the call
        // evaluates to is true the include directive will be ignored completely.
        IgnoreInclude *regexp.Regexp

        // Name of a macro to use instead of FD_ZERO.
        //
        // Note: Temporary solution will be removed/replaced
        ReplaceMacroFdZero string
        // Name of a macro to use instead of TCL_DEFAULT_DOUBLE_ROUNDING.
        //
        // Note: Temporary solution will be removed/replaced
        ReplaceMacroTclDefaultDoubleRounding string // Name of a macro to use instead of TCL_DEFAULT_DOUBLE_ROUNDING. Note: Temporrary solution will be removed/replaced
        // Name of a macro to use instead of TCL_IEEE_DOUBLE_ROUNDING.
        //
        // Note: Temporary solution will be removed/replaced
        ReplaceMacroTclIeeeDoubleRounding string

        WorkingDir string     // Overrides os.Getwd if non empty.
        Filesystem Filesystem // Overrides filesystem access if not empty.

        MaxSourceLine int // Zero: Scanner will use default buffer. Non zero: Scanner will use max(default buffer size, MaxSourceLine).

        // DisableBuiltinResolution disables resolution of undefined identifiers such
        // that eg. abort, becomes the same as __builtin_abort, prototype of which is
        // expected to be provided by one of the sources passed to Parse, Preprocess or
        // Translate.
        DisableBuiltinResolution bool

        DisableTrigraphs bool // GCC ignores them unless -trigraphs is used: https://gcc.gnu.org/onlinedocs/cpp/Initial-processing.html
        GCCStructs       bool // Assume __attribute__(gcc_struct) applied to structs by default.
        //TODO MSStructs                               bool // Assume __attribute__(ms_struct) applied to structs by default.
        NoFieldAndBitfieldOverlap               bool // Only bitfields can be grouped together.
        PreserveOnlyLastNonBlankSeparator       bool // If PreserveWhiteSpace is true, keep only the last white space, do not combine
        PreserveWhiteSpace                      bool // Including also comments.
        RejectElseExtraTokens                   bool // Pedantic: do not silently accept "#else foo".
        RejectEndifExtraTokens                  bool // Pedantic: do not silently accept "#endif foo".
        RejectFinalBackslash                    bool // Pedantic: do not silently accept "foo\\\n".
        RejectFunctionMacroEmptyReplacementList bool // Pedantic: do not silently accept "#define foo(bar)\n".
        RejectIfdefExtraTokens                  bool // Pedantic: do not silently accept "#ifdef foo bar".
        RejectIfndefExtraTokens                 bool // Pedantic: do not silently accept "#ifndef foo bar".
        RejectIncludeNext                       bool // Pedantic: do not silently accept "#include_next".
        RejectInvalidVariadicMacros             bool // Pedantic: do not silently accept "#define foo(bar...)". Standard allows only #define foo(bar, ...)
        RejectLineExtraTokens                   bool // Pedantic: do not silently accept "#line 1234 \"foo.c\" bar".
        RejectMissingFinalNewline               bool // Pedantic: do not silently accept "foo\nbar".
        RejectUndefExtraTokens                  bool // Pedantic: do not silently accept "#undef foo bar".
        UnsignedEnums                           bool // GCC compatibility: enums with no negative values will have unsigned type.
}

type SharedFunctionDefinitions struct {
        M    map[*FunctionDefinition]struct{}
        m    map[sharedFunctionDefinitionKey]*FunctionDefinition //TODO
        hash maphash.Hash
}

type sharedFunctionDefinitionKey struct {
        pos  StringID
        nm   StringID
        hash uint64
}

// Config amends behavior of translation phase 4 and above. Instances of Config
// are not mutated by this package and it's safe to share/reuse them.
//
// The *Config passed to Parse or Translate should not be mutated afterwards.
type Config struct {
        Config3
        ABI ABI

        PragmaHandler func(Pragma, []Token) // Called on pragmas, other than #pragma STDC ..., if non nil

        // SharedFunctionDefinitions collects function definitions having the same
        // position and definition. This can happen, for example, when a function is
        // defined in a header file included multiple times. Either within a single
        // translation unit or across translation units. In the later case just supply
        // the same SharedFunctionDefinitions in Config when translating/parsing each
        // translation unit.
        SharedFunctionDefinitions *SharedFunctionDefinitions

        // IncludeFileHandler, when non nil, is called by the preprocessor for every
        // successfully included file.
        IncludeFileHandler func(pos gotoken.Position, includePath string)

        MaxErrors int // 0: default (10), < 0: unlimited, n: n.

        CheckExternInlineFnBodies              bool // Translate will consider extern inline function bodies.
        DebugIncludePaths                      bool // Output to stderr.
        DebugWorkingDir                        bool // Output to stderr.
        DoNotTypecheckAsm                      bool
        EnableAssignmentCompatibilityChecking  bool // No such checks performed up to v3.31.0. Currently only partially implemented.
        FixBitfieldPadding                     bool // Fix a bug in calculating field positions after a bitfield.
        InjectTracingCode                      bool // Output to stderr.
        LongDoubleIsDouble                     bool
        PreprocessOnly                         bool
        RejectAnonymousFields                  bool // Pedantic: do not silently accept "struct{int;}".
        RejectCaseRange                        bool // Pedantic: do not silently accept "case 'a'...'z':".
        RejectEmptyCompositeLiterals           bool // Pedantic: do not silently accept "foo = (T){}".
        RejectEmptyDeclarations                bool // Pedantic: do not silently accept "int foo(){};".
        RejectEmptyFields                      bool // Pedantic: do not silently accept "struct {int a;;} foo;".
        RejectEmptyInitializerList             bool // Pedantic: do not silently accept "foo f = {};".
        RejectEmptyStructDeclaration           bool // Pedantic: do not silently accept "struct{; int i}".
        RejectEmptyStructs                     bool // Pedantic: do not silently accept "struct foo {};".
        RejectIncompatibleMacroRedef           bool // Pedantic: do not silently accept "#define MIN(A,B) ...\n#define MIN(a,b) ...\n" etc.
        RejectLabelValues                      bool // Pedantic: do not silently accept "foo: bar(); void *ptr = &&foo;" or "goto *ptr".
        RejectLateBinding                      bool // Pedantic: do not silently accept void f() { g(); } void g() {}
        RejectMissingConditionalExpr           bool // Pedantic: do not silently accept "foo = bar ? : baz;".
        RejectMissingDeclarationSpecifiers     bool // Pedantic: do not silently accept "main() {}".
        RejectMissingFinalStructFieldSemicolon bool // Pedantic: do not silently accept "struct{int i; int j}".
        RejectNestedFunctionDefinitions        bool // Pedantic: do not silently accept nested function definitons.
        RejectParamSemicolon                   bool // Pedantic: do not silently accept "int f(int a; int b)".
        RejectStatementExpressions             bool // Pedantic: do not silently accept "i = ({foo();})".
        RejectTypeof                           bool // Pedantic: do not silently accept "typeof foo" or "typeof(bar*)".
        RejectUninitializedDeclarators         bool // Reject int f() { int j; return j; }
        TrackAssignments                       bool // Collect a list of LHS declarators a declarator is used in RHS or as an function argument.
        doNotSanityCheckComplexTypes           bool // Testing only
        fakeIncludes                           bool // Testing only.
        ignoreErrors                           bool // Testing only.
        ignoreIncludes                         bool // Testing only.
        ignoreUndefinedIdentifiers             bool // Testing only.
}

type context struct {
        ast         *AST
        breakCtx    Node
        breaks      int
        casePromote Type
        cases       []*LabeledStatement // switch
        cfg         *Config
        checkFn     *FunctionDefinition
        closure     map[StringID]struct{}
        continues   int
        enums       map[StringID]Operand //TODO putting this in alphabetical order within the struct causes crashes in VirtualBox/386 ???
        goscanner.ErrorList
        includePaths    []string
        intBits         int
        intMaxWidth     int64 // Set if the preprocessor saw __INTMAX_WIDTH__.
        keywords        map[StringID]rune
        maxAlign        int // If non zero: maximum alignment of members of structures (other than zero-width bitfields).
        maxAlign0       int
        maxErrors       int
        mode            mode
        modes           []mode
        mu              sync.Mutex
        ptrdiffT        Type
        readDelta       int
        sizeT           Type
        structTypes     map[StringID]Type
        structs         map[StructInfo]struct{}
        switches        int
        sysIncludePaths []string
        tuSize0         int64 // Sum of sizes of processed inputs
        tuSources0      int32 // Number of processed inputs
        wcharT          Type

        capture        bool
        evalIdentError bool
}

func newContext(cfg *Config) *context {
        maxErrors := cfg.MaxErrors
        if maxErrors == 0 {
                maxErrors = 10
        }
        return &context{
                cfg:         cfg,
                enums:       map[StringID]Operand{},
                keywords:    keywords,
                maxErrors:   maxErrors,
                structTypes: map[StringID]Type{},
                structs:     map[StructInfo]struct{}{},
        }
}

func (c *context) tuSizeAdd(n int64)    { atomic.AddInt64(&c.tuSize0, n) }
func (c *context) tuSize() int64        { return atomic.LoadInt64(&c.tuSize0) }
func (c *context) tuSourcesAdd(n int32) { atomic.AddInt32(&c.tuSources0, n) }
func (c *context) tuSources() int       { return int(atomic.LoadInt32(&c.tuSources0)) }

func (c *context) stddef(nm StringID, s Scope, tok Token) Type {
        if d := s.typedef(nm, tok); d != nil {
                if t := d.Type(); t != nil && t.Kind() != Invalid {
                        return t
                }
        }

        c.errNode(&tok, "front-end: undefined: %s", nm)
        return noType
}

func (c *context) assignmentCompatibilityErrorCond(n Node, a, b Type) (stop bool) {
        if !c.cfg.EnableAssignmentCompatibilityChecking {
                return
        }

        return c.errNode(n, "invalid type combination of conditional operator: %v and %v", a, b)
}

func (c *context) assignmentCompatibilityError(n Node, lhs, rhs Type) (stop bool) {
        if !c.cfg.EnableAssignmentCompatibilityChecking {
                return
        }

        return c.errNode(n, "cannot use %v as type %v in assignment", rhs, lhs)
}

func (c *context) errNode(n Node, msg string, args ...interface{}) (stop bool) {
        return c.err(n.Position(), msg, args...)
}

func (c *context) err(pos token.Position, msg string, args ...interface{}) (stop bool) {
        // dbg("FAIL "+msg, args...)
        //fmt.Printf("FAIL "+msg+"\n", args...)
        if c.cfg.ignoreErrors {
                return false
        }

        s := fmt.Sprintf(msg, args...)
        c.mu.Lock()
        max := c.maxErrors
        switch {
        case max < 0 || max > len(c.ErrorList):
                c.ErrorList.Add(gotoken.Position(pos), s)
        default:
                stop = true
        }
        c.mu.Unlock()
        return stop
}

func (c *context) errs(list goscanner.ErrorList) (stop bool) {
        c.mu.Lock()

        defer c.mu.Unlock()

        max := c.maxErrors
        for _, v := range list {
                switch {
                case max < 0 || max > len(c.ErrorList):
                        c.ErrorList = append(c.ErrorList, v)
                default:
                        return true
                }
        }
        return false
}

func (c *context) Err() error {
        c.mu.Lock()
        switch x := c.ErrorList.Err().(type) {
        case goscanner.ErrorList:
                x = append(goscanner.ErrorList(nil), x...)
                c.mu.Unlock()
                var lpos gotoken.Position
                w := 0
                for _, v := range x {
                        if lpos.Filename != "" {
                                if v.Pos.Filename == lpos.Filename && v.Pos.Line == lpos.Line {
                                        continue
                                }
                        }

                        x[w] = v
                        w++
                        lpos = v.Pos
                }
                x = x[:w]
                sort.Slice(x, func(i, j int) bool {
                        a := x[i]
                        b := x[j]
                        if !a.Pos.IsValid() && b.Pos.IsValid() {
                                return true
                        }

                        if a.Pos.IsValid() && !b.Pos.IsValid() {
                                return false
                        }

                        if a.Pos.Filename < b.Pos.Filename {
                                return true
                        }

                        if a.Pos.Filename > b.Pos.Filename {
                                return false
                        }

                        if a.Pos.Line < b.Pos.Line {
                                return true
                        }

                        if a.Pos.Line > b.Pos.Line {
                                return false
                        }

                        return a.Pos.Column < b.Pos.Column
                })
                a := make([]string, 0, len(x))
                for _, v := range x {
                        a = append(a, v.Error())
                }
                return fmt.Errorf("%s", strings.Join(a, "\n"))
        default:
                c.mu.Unlock()
                return x
        }
}

func (c *context) not(n Node, mode mode) {
        if c.mode&mode != 0 {
                switch mode {
                case mIntConstExpr:
                        c.errNode(n, "invalid integer constant expression")
                default:
                        panic(internalError())
                }
        }
}

func (c *context) push(mode mode) {
        c.modes = append(c.modes, c.mode)
        c.mode = mode
}

func (c *context) pop() {
        n := len(c.modes)
        c.mode = c.modes[n-1]
        c.modes = c.modes[:n-1]
}

func (c *context) statFile(name string, sys bool) (os.FileInfo, error) {
        fs := c.cfg.Config3.Filesystem
        if fs == nil {
                fs = LocalFS()
        }
        return fs.Stat(name, sys)
}

func (c *context) openFile(name string, sys bool) (io.ReadCloser, error) {
        fs := c.cfg.Config3.Filesystem
        if fs == nil {
                fs = LocalFS()
        }
        return fs.Open(name, sys)
}

// HostConfig returns the system C preprocessor/compiler configuration, or an
// error, if any.  The configuration is obtained by running the command named
// by the cpp argumnent or "cpp" when it's empty.  For the predefined macros
// list the '-dM' options is added. For the include paths lists, the option
// '-v' is added and the output is parsed to extract the "..." include and
// <...> include paths. To add any other options to cpp, list them in opts.
//
// The function relies on a POSIX/GCC compatible C preprocessor installed.
// Execution of HostConfig is not free, so caching of the results is
// recommended.
func HostConfig(cpp string, opts ...string) (predefined string, includePaths, sysIncludePaths []string, err error) {
        if predefined, includePaths, sysIncludePaths, err = hostConfigv3(cpp, opts...); err == nil {
                return predefined, includePaths, sysIncludePaths, nil
        }

        return hostConfigv4(opts)
}

func hostConfigv3(cpp string, opts ...string) (predefined string, includePaths, sysIncludePaths []string, err error) {
        if cpp == "" {
                cpp = "cpp"
        }
        args := append(append([]string{"-dM"}, opts...), os.DevNull)
        pre, err := exec.Command(cpp, args...).Output()
        if err != nil {
                return "", nil, nil, err
        }

        args = append(append([]string{"-v"}, opts...), os.DevNull)
        out, err := exec.Command(cpp, args...).CombinedOutput()
        if err != nil {
                return "", nil, nil, err
        }

        sep := "\n"
        if env("GOOS", runtime.GOOS) == "windows" {
                sep = "\r\n"
        }

        a := strings.Split(string(out), sep)
        for i := 0; i < len(a); {
                switch a[i] {
                case "#include \"...\" search starts here:":
                loop:
                        for i = i + 1; i < len(a); {
                                switch v := a[i]; {
                                case strings.HasPrefix(v, "#") || v == "End of search list.":
                                        break loop
                                default:
                                        includePaths = append(includePaths, strings.TrimSpace(v))
                                        i++
                                }
                        }
                case "#include <...> search starts here:":
                        for i = i + 1; i < len(a); {
                                switch v := a[i]; {
                                case strings.HasPrefix(v, "#") || v == "End of search list.":
                                        return string(pre), includePaths, sysIncludePaths, nil
                                default:
                                        sysIncludePaths = append(sysIncludePaths, strings.TrimSpace(v))
                                        i++
                                }
                        }
                default:
                        i++
                }
        }
        return "", nil, nil, fmt.Errorf("failed parsing %s -v output", cpp)
}

func hostConfigv4(opts []string) (predefined string, includePaths, sysIncludePaths []string, err error) {
        for _, cc := range []string{os.Getenv("CC"), "cc", "gcc"} {
                if cc == "" {
                        continue
                }

                cc, err = exec.LookPath(cc)
                if err != nil {
                        continue
                }

                args := append(opts, "-dM", "-E", "-")
                pre, err := exec.Command(cc, args...).CombinedOutput()
                if err != nil {
                        continue
                }

                sep := "\n"
                if env("GOOS", runtime.GOOS) == "windows" {
                        sep = "\r\n"
                }
                a := strings.Split(string(pre), sep)
                w := 0
                for _, v := range a {
                        if strings.HasPrefix(v, "#") {
                                a[w] = v
                                w++
                        }
                }
                predefined = strings.Join(a[:w], "\n")
                args = append(opts, "-v", "-E", "-")
                out, err := exec.Command(cc, args...).CombinedOutput()
                if err != nil {
                        continue
                }

                a = strings.Split(string(out), sep)
                for i := 0; i < len(a); {
                        switch a[i] {
                        case "#include \"...\" search starts here:":
                        loop:
                                for i = i + 1; i < len(a); {
                                        switch v := a[i]; {
                                        case strings.HasPrefix(v, "#") || v == "End of search list.":
                                                break loop
                                        default:
                                                includePaths = append(includePaths, strings.TrimSpace(v))
                                                i++
                                        }
                                }
                        case "#include <...> search starts here:":
                                for i = i + 1; i < len(a); {
                                        switch v := a[i]; {
                                        case strings.HasPrefix(v, "#") || v == "End of search list.":
                                                return predefined, includePaths, sysIncludePaths, nil
                                        default:
                                                sysIncludePaths = append(sysIncludePaths, strings.TrimSpace(v))
                                                i++
                                        }
                                }
                        default:
                                i++
                        }
                }
        }
        return "", nil, nil, fmt.Errorf("cannot determine C compiler configuration")
}

func env(key, val string) string {
        if s := os.Getenv(key); s != "" {
                return s
        }

        return val
}

// Token is a grammar terminal.
type Token struct {
        Rune  rune     // ';' or IDENTIFIER etc.
        Sep   StringID // If Config3.PreserveWhiteSpace is in effect: All preceding white space combined, including comments.
        Value StringID // ";" or "foo" etc.
        Src   StringID
        file  *tokenFile
        macro StringID
        pos   int32
        seq   int32
}

// Seq returns t's sequential number.
//
// Comparing positions as in 'before', 'after' is complicated as tokens in a
// translation unit usually come from more than one source file. Macro
// expansion further complicates that. The solution is sequentially numbering
// the tokens as they are finally seen by the parser, so the usual arithmetic
// '<', '>' operators can be used for that purpose.
func (t Token) Seq() int { return int(t.seq) }

// Macro returns the name of a macro that expanded to this token, if any.
func (t *Token) Macro() StringID { return t.macro }

// String implements fmt.Stringer.
func (t Token) String() string { return t.Value.String() }

// Position implements Node.
func (t *Token) Position() (r token.Position) {
        if t.pos != 0 && t.file != nil {
                r = t.file.PositionFor(token.Pos(t.pos), true)
        }
        return r
}

func tokStr(toks interface{}, sep string) string {
        var b strings.Builder
        switch x := toks.(type) {
        case []token3:
                for i, v := range x {
                        if i != 0 {
                                b.WriteString(sep)
                        }
                        b.WriteString(v.String())
                }
        case []token4:
                for i, v := range x {
                        if i != 0 {
                                b.WriteString(sep)
                        }
                        b.WriteString(v.String())
                }
        case []cppToken:
                for i, v := range x {
                        if i != 0 {
                                b.WriteString(sep)
                        }
                        b.WriteString(v.String())
                }
        case []Token:
                for i, v := range x {
                        if i != 0 {
                                b.WriteString(sep)
                        }
                        b.WriteString(v.String())
                }
        default:
                panic(internalError())
        }
        return b.String()
}

func internalError() int {
        panic(fmt.Errorf("%v: internal error", origin(2)))
}

func internalErrorf(s string, args ...interface{}) int {
        s = fmt.Sprintf(s, args)
        panic(fmt.Errorf("%v: %s", origin(2), s))
}

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

func nodeSource(n ...Node) (r string) {
        if len(n) == 0 {
                return ""
        }

        var a []*Token
        for _, v := range n {
                Inspect(v, func(n Node, _ bool) bool {
                        if x, ok := n.(*Token); ok && x.Seq() != 0 {
                                a = append(a, x)
                        }
                        return true
                })
        }
        sort.Slice(a, func(i, j int) bool {
                return a[i].Seq() < a[j].Seq()
        })
        w := 0
        seq := -1
        for _, v := range a {
                if n := v.Seq(); n != seq {
                        seq = n
                        a[w] = v
                        w++
                }
        }
        a = a[:w]
        var b strings.Builder
        for _, v := range a {
                b.WriteString(v.Sep.String())
                b.WriteString(v.Src.String())
        }
        return b.String()
}