gtsocial-umbx

cc.go (29618B)

---

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