gtsocial-umbx

cpp.go (69747B)

---

 // 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.
 
 package cc // import "modernc.org/cc/v3"
 
 import (
 	"bytes"
 	"fmt"
 	gotoken "go/token"
 	"math"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 	"unicode/utf8"
 
 	"modernc.org/token"
 )
 
 const (
 	maxIncludeLevel = 200 // gcc, std is at least 15.
 )
 
 var (
 	_ tokenReader = (*cpp)(nil)
 	_ tokenWriter = (*cpp)(nil)
 
 	idCOUNTER                  = dict.sid("__COUNTER__")
 	idCxLimitedRange           = dict.sid("CX_LIMITED_RANGE")
 	idDATE                     = dict.sid("__DATE__")
 	idDefault                  = dict.sid("DEFAULT")
 	idDefined                  = dict.sid("defined")
 	idEmptyString              = dict.sid(`""`)
 	idFILE                     = dict.sid("__FILE__")
 	idFPContract               = dict.sid("FP_CONTRACT")
 	idFdZero                   = dict.sid("FD_ZERO")
 	idFenvAccess               = dict.sid("FENV_ACCESS")
 	idGNUC                     = dict.sid("__GNUC__")
 	idHasIncludeImpl           = dict.sid("__has_include_impl")
 	idIntMaxWidth              = dict.sid("__INTMAX_WIDTH__")
 	idL                        = dict.sid("L")
 	idLINE                     = dict.sid("__LINE__")
 	idNL                       = dict.sid("\n")
 	idOff                      = dict.sid("OFF")
 	idOn                       = dict.sid("ON")
 	idOne                      = dict.sid("1")
 	idPragmaSTDC               = dict.sid("__pragma_stdc")
 	idSTDC                     = dict.sid("STDC")
 	idTIME                     = dict.sid("__TIME__")
 	idTclDefaultDoubleRounding = dict.sid("TCL_DEFAULT_DOUBLE_ROUNDING")
 	idTclIeeeDoubleRounding    = dict.sid("TCL_IEEE_DOUBLE_ROUNDING")
 	idVaArgs                   = dict.sid("__VA_ARGS__")
 	idZero                     = dict.sid("0")
 
 	cppTokensPool = sync.Pool{New: func() interface{} { r := []cppToken{}; return &r }}
 
 	protectedMacros = hideSet{ // [0], 6.10.8, 4
 		dict.sid("__STDC_HOSTED__"):          {},
 		dict.sid("__STDC_IEC_559_COMPLEX__"): {},
 		dict.sid("__STDC_IEC_559__"):         {},
 		dict.sid("__STDC_ISO_10646__"):       {},
 		dict.sid("__STDC_MB_MIGHT_NEQ_WC__"): {},
 		dict.sid("__STDC_VERSION__"):         {},
 		dict.sid("__STDC__"):                 {},
 		idCOUNTER:                            {},
 		idDATE:                               {},
 		idFILE:                               {},
 		idLINE:                               {},
 		idTIME:                               {},
 	}
 )
 
 type tokenReader interface {
 	read() (cppToken, bool)
 	unget(cppToken)
 	ungets([]cppToken)
 }
 
 type tokenWriter interface {
 	write(cppToken)
 	writes([]cppToken)
 }
 
 // token4 is produced by translation phase 4.
 type token4 struct {
 	file *tokenFile //TODO sort fields
 	token3
 }
 
 func (t *token4) Position() (r token.Position) {
 	if t.pos != 0 && t.file != nil {
 		r = t.file.PositionFor(token.Pos(t.pos), true)
 	}
 	return r
 }
 
 type hideSet map[StringID]struct{}
 
 type cppToken struct {
 	token4
 	hs hideSet
 }
 
 func (t *cppToken) has(nm StringID) bool { _, ok := t.hs[nm]; return ok }
 
 type cppWriter struct {
 	toks []cppToken
 }
 
 func (w *cppWriter) write(tok cppToken)     { w.toks = append(w.toks, tok) }
 func (w *cppWriter) writes(toks []cppToken) { w.toks = append(w.toks, toks...) }
 
 type ungetBuf []cppToken
 
 func (u *ungetBuf) unget(t cppToken) { *u = append(*u, t) }
 
 func (u *ungetBuf) read() (t cppToken) {
 	s := *u
 	n := len(s) - 1
 	t = s[n]
 	*u = s[:n]
 	return t
 }
 func (u *ungetBuf) ungets(toks []cppToken) {
 	s := *u
 	for i := len(toks) - 1; i >= 0; i-- {
 		s = append(s, toks[i])
 	}
 	*u = s
 }
 
 func cppToksStr(toks []cppToken, sep string) string {
 	var b strings.Builder
 	for i, v := range toks {
 		if i != 0 {
 			b.WriteString(sep)
 		}
 		b.WriteString(v.String())
 	}
 	return b.String()
 }
 
 func cppToksStr2(toks [][]cppToken) string {
 	panic(todo(""))
 	var a []string
 	for _, v := range toks {
 		a = append(a, fmt.Sprintf("%q", cppToksStr(v, "|")))
 	}
 	return fmt.Sprint(a)
 }
 
 type cppReader struct {
 	buf []cppToken
 	ungetBuf
 }
 
 func (r *cppReader) read() (tok cppToken, ok bool) {
 	if len(r.ungetBuf) != 0 {
 		return r.ungetBuf.read(), true
 	}
 
 	if len(r.buf) == 0 {
 		return tok, false
 	}
 
 	tok = r.buf[0]
 	r.buf = r.buf[1:]
 	return tok, true
 }
 
 type cppScanner []cppToken
 
 func (s *cppScanner) peek() (r cppToken) {
 	r.char = -1
 	if len(*s) == 0 {
 		return r
 	}
 
 	return (*s)[0]
 }
 
 func (s *cppScanner) next() (r cppToken) {
 	r.char = -1
 	if len(*s) == 0 {
 		return r
 	}
 
 	*s = (*s)[1:]
 	return s.peek()
 }
 
 func (s *cppScanner) Pos() token.Pos {
 	if len(*s) == 0 {
 		return 0
 	}
 
 	return (*s)[0].Pos()
 }
 
 // Macro represents a preprocessor macro definition.
 type Macro struct {
 	fp    []StringID
 	repl  []token3
 	repl2 []Token
 
 	name token4
 	pos  int32
 
 	isFnLike      bool
 	namedVariadic bool // foo..., note no comma before ellipsis.
 	variadic      bool
 }
 
 // Position reports the position of the macro definition.
 func (m *Macro) Position() token.Position {
 	if m.pos != 0 && m.name.file != nil {
 		return m.name.file.PositionFor(token.Pos(m.pos), true)
 	}
 	return token.Position{}
 }
 
 // Parameters return the list of function-like macro parameters.
 func (m *Macro) Parameters() []StringID { return m.fp }
 
 // ReplacementTokens return the list of tokens m is replaced with. Tokens in
 // the returned list have only the Rune and Value fields valid.
 func (m *Macro) ReplacementTokens() []Token {
 	if m.repl2 != nil {
 		return m.repl2
 	}
 
 	m.repl2 = make([]Token, len(m.repl))
 	for i, v := range m.repl {
 		m.repl2[i] = Token{Rune: v.char, Value: v.value, Src: v.src}
 	}
 	return m.repl2
 }
 
 // IsFnLike reports whether m is a function-like macro.
 func (m *Macro) IsFnLike() bool { return m.isFnLike }
 
 func (m *Macro) isNamedVariadicParam(nm StringID) bool {
 	return m.namedVariadic && nm == m.fp[len(m.fp)-1]
 }
 
 func (m *Macro) param2(varArgs []cppToken, ap [][]cppToken, nm StringID, out *[]cppToken, argIndex *int) bool {
 	*out = nil
 	if nm == idVaArgs || m.isNamedVariadicParam(nm) {
 		if !m.variadic {
 			return false
 		}
 
 		*out = append([]cppToken(nil), varArgs...)
 		return true
 	}
 
 	for i, v := range m.fp {
 		if v == nm {
 			if i < len(ap) {
 				a := ap[i]
 				for len(a) != 0 && a[0].char == ' ' {
 					a = a[1:]
 				}
 				*out = a
 			}
 			if argIndex != nil {
 				*argIndex = i
 			}
 			return true
 		}
 	}
 	return false
 }
 
 func (m *Macro) param(varArgs []cppToken, ap [][]cppToken, nm StringID, out *[]cppToken) bool {
 	// trc("select (A) varArgs %q, ap %v, nm %q, out %q", cppToksStr(varArgs, "|"), cppToksStr2(ap), nm, cppToksStr(*out, "|"))
 	// defer func() {
 	// 	trc("select (A) varArgs %q, ap %v, nm %q, out %q", cppToksStr(varArgs, "|"), cppToksStr2(ap), nm, cppToksStr(*out, "|"))
 	// }()
 	return m.param2(varArgs, ap, nm, out, nil)
 }
 
 // --------------------------------------------------------------- Preprocessor
 
 type cpp struct {
 	counter      int
 	counterMacro Macro
 	ctx          *context
 	dateMacro    Macro
 	file         *tokenFile
 	fileMacro    Macro
 	in           chan []token3
 	inBuf        []token3
 	includeLevel int
 	lineMacro    Macro
 	macroStack   map[StringID][]*Macro
 	macros       map[StringID]*Macro
 	out          chan *[]token4
 	outBuf       *[]token4
 	pragmaOpBuf  []token4
 	rq           chan struct{}
 	timeMacro    Macro
 	ungetBuf
 
 	last rune
 
 	intmaxChecked bool
 	nonFirstRead  bool
 	seenEOF       bool
 	inPragmaOp    bool
 }
 
 func newCPP(ctx *context) *cpp {
 	b := token4Pool.Get().(*[]token4)
 	*b = (*b)[:0]
 	r := &cpp{
 		ctx:        ctx,
 		macroStack: map[StringID][]*Macro{},
 		macros:     map[StringID]*Macro{},
 		outBuf:     b,
 	}
 	r.counterMacro = Macro{repl: []token3{{char: PPNUMBER}}}
 	r.dateMacro = Macro{repl: []token3{{char: STRINGLITERAL}}}
 	r.timeMacro = Macro{repl: []token3{{char: STRINGLITERAL}}}
 	r.fileMacro = Macro{repl: []token3{{char: STRINGLITERAL}}}
 	r.lineMacro = Macro{repl: []token3{{char: PPNUMBER}}}
 	r.macros = map[StringID]*Macro{
 		idCOUNTER: &r.counterMacro,
 		idDATE:    &r.dateMacro,
 		idFILE:    &r.fileMacro,
 		idLINE:    &r.lineMacro,
 		idTIME:    &r.timeMacro,
 	}
 	t := time.Now()
 	// This macro expands to a string constant that describes the date on which the
 	// preprocessor is being run. The string constant contains eleven characters
 	// and looks like "Feb 12 1996". If the day of the month is less than 10, it is
 	// padded with a space on the left.
 	r.dateMacro.repl[0].value = dict.sid(t.Format("\"Jan _2 2006\""))
 	// This macro expands to a string constant that describes the time at which the
 	// preprocessor is being run. The string constant contains eight characters and
 	// looks like "23:59:01".
 	r.timeMacro.repl[0].value = dict.sid(t.Format("\"15:04:05\""))
 	return r
 }
 
 func (c *cpp) cppToks(toks []token3) (r []cppToken) {
 	r = make([]cppToken, len(toks))
 	for i, v := range toks {
 		r[i].token4.token3 = v
 		r[i].token4.file = c.file
 	}
 	return r
 }
 
 func (c *cpp) err(n node, msg string, args ...interface{}) (stop bool) {
 	var position token.Position
 	switch x := n.(type) {
 	case nil:
 	case token4:
 		position = x.Position()
 	default:
 		if p := n.Pos(); p.IsValid() {
 			position = c.file.PositionFor(p, true)
 		}
 	}
 	return c.ctx.err(position, msg, args...)
 }
 
 func (c *cpp) read() (cppToken, bool) {
 	if len(c.ungetBuf) != 0 {
 		return c.ungetBuf.read(), true
 	}
 
 	if len(c.inBuf) == 0 {
 		if c.seenEOF {
 			return cppToken{}, false
 		}
 
 		if c.nonFirstRead {
 			c.rq <- struct{}{}
 		}
 		c.nonFirstRead = true
 
 		var ok bool
 		if c.inBuf, ok = <-c.in; !ok {
 			c.seenEOF = true
 			return cppToken{}, false
 		}
 	}
 
 	tok := c.inBuf[0]
 	c.inBuf = c.inBuf[1:]
 	return cppToken{token4{token3: tok, file: c.file}, nil}, true
 }
 
 func (c *cpp) write(tok cppToken) {
 	if tok.char == ' ' && c.last == ' ' {
 		return
 	}
 
 	if c.ctx.cfg.PreprocessOnly {
 		switch {
 		case
 			//TODO cover ALL the bad combinations
 			c.last == '+' && tok.char == '+',
 			c.last == '+' && tok.char == INC,
 			c.last == '-' && tok.char == '-',
 			c.last == '-' && tok.char == DEC,
 			c.last == IDENTIFIER && tok.char == IDENTIFIER,
 			c.last == PPNUMBER && tok.char == '+', //TODO not when ends in a digit
 			c.last == PPNUMBER && tok.char == '-': //TODO not when ends in a digit
 
 			sp := tok
 			sp.char = ' '
 			sp.value = idSpace
 			*c.outBuf = append(*c.outBuf, sp.token4)
 		}
 	}
 
 	//dbg("%T.write %q", c, tok)
 	c.last = tok.char
 	switch {
 	case c.inPragmaOp:
 	out:
 		switch tok.char {
 		case ')':
 			c.inPragmaOp = false
 			b := c.pragmaOpBuf
 			if len(b) == 0 || b[0].char != '(' {
 				c.err(b[0], "expected (")
 				break
 			}
 
 			var a []string
 			for _, v := range b[1:] {
 				if v.char != STRINGLITERAL {
 					c.err(v, "expected string literal")
 					break out
 				}
 
 				a = append(a, v.String())
 			}
 
 			if len(a) == 0 {
 				break
 			}
 
 			for i, v := range a {
 				// [0], 6.10.9, 1
 				if v[0] == 'L' {
 					v = v[1:]
 				}
 				v = v[1 : len(v)-1]
 				v = strings.ReplaceAll(v, `\"`, `"`)
 				a[i] = "#pragma " + strings.ReplaceAll(v, `\\`, `\`) + "\n"
 			}
 			src := strings.Join(a, "")
 			s := newScanner0(c.ctx, strings.NewReader(src), tokenNewFile("", len(src)), 4096)
 			if ppf := s.translationPhase3(); ppf != nil {
 				ppf.translationPhase4(c)
 			}
 		default:
 			c.pragmaOpBuf = append(c.pragmaOpBuf, tok.token4)
 		}
 	default:
 		switch {
 		case tok.char == '\n':
 			*c.outBuf = append(*c.outBuf, tok.token4)
 			c.out <- c.outBuf
 			b := token4Pool.Get().(*[]token4)
 			*b = (*b)[:0]
 			c.outBuf = b
 		case tok.char == IDENTIFIER && tok.value == idPragmaOp:
 			if len(*c.outBuf) != 0 {
 				tok.char = '\n'
 				tok.value = 0
 				*c.outBuf = append(*c.outBuf, tok.token4)
 				c.out <- c.outBuf
 				b := token4Pool.Get().(*[]token4)
 				*b = (*b)[:0]
 				c.outBuf = b
 			}
 			c.inPragmaOp = true
 			c.pragmaOpBuf = c.pragmaOpBuf[:0]
 		default:
 			*c.outBuf = append(*c.outBuf, tok.token4)
 		}
 	}
 }
 
 func ltrim4(toks []token4) []token4 {
 	for len(toks) != 0 && toks[0].char == ' ' {
 		toks = toks[1:]
 	}
 	return toks
 }
 
 func (c *cpp) writes(toks []cppToken) {
 	for _, v := range toks {
 		c.write(v)
 	}
 }
 
 // [1]pg 1.
 //
 // expand(TS) /* recur, substitute, pushback, rescan */
 // {
 // 	if TS is {} then
 //		// ---------------------------------------------------------- A
 // 		return {};
 //
 // 	else if TS is T^HS • TS’ and T is in HS then
 //		//----------------------------------------------------------- B
 // 		return T^HS • expand(TS’);
 //
 // 	else if TS is T^HS • TS’ and T is a "()-less macro" then
 //		// ---------------------------------------------------------- C
 // 		return expand(subst(ts(T), {}, {}, HS \cup {T}, {}) • TS’ );
 //
 // 	else if TS is T^HS •(•TS’ and T is a "()’d macro" then
 //		// ---------------------------------------------------------- D
 // 		check TS’ is actuals • )^HS’ • TS’’ and actuals are "correct for T"
 // 		return expand(subst(ts(T), fp(T), actuals,(HS \cap HS’) \cup {T }, {}) • TS’’);
 //
 //	// ------------------------------------------------------------------ E
 // 	note TS must be T^HS • TS’
 // 	return T^HS • expand(TS’);
 // }
 func (c *cpp) expand(ts tokenReader, w tokenWriter, expandDefined bool) {
 	// trc("==== expand enter")
 start:
 	tok, ok := ts.read()
 	tok.file = c.file
 	// First, if TS is the empty set, the result is the empty set.
 	if !ok {
 		// ---------------------------------------------------------- A
 		// return {};
 		// trc("---- expand A")
 		return
 	}
 
 	// dbg("expand start %q", tok)
 	if tok.char == IDENTIFIER {
 		nm := tok.value
 		if nm == idDefined && expandDefined {
 			c.parseDefined(tok, ts, w)
 			goto start
 		}
 
 		// Otherwise, if the token sequence begins with a token whose
 		// hide set contains that token, then the result is the token
 		// sequence beginning with that token (including its hide set)
 		// followed by the result of expand on the rest of the token
 		// sequence.
 		if tok.has(nm) {
 			// -------------------------------------------------- B
 			// return T^HS • expand(TS’);
 			// trc("---- expand B")
 			// trc("expand write %q", tok)
 			w.write(tok)
 			goto start
 		}
 
 		m := c.macros[nm]
 		if m != nil && !m.isFnLike {
 			// Otherwise, if the token sequence begins with an
 			// object-like macro, the result is the expansion of
 			// the rest of the token sequence beginning with the
 			// sequence returned by subst invoked with the
 			// replacement token sequence for the macro, two empty
 			// sets, the union of the macro’s hide set and the
 			// macro itself, and an empty set.
 			switch nm {
 			case idLINE:
 				c.lineMacro.repl[0].value = dict.sid(fmt.Sprint(tok.Position().Line))
 			case idCOUNTER:
 				c.counterMacro.repl[0].value = dict.sid(fmt.Sprint(c.counter))
 				c.counter++
 			case idTclDefaultDoubleRounding:
 				if c.ctx.cfg.ReplaceMacroTclDefaultDoubleRounding != "" {
 					m = c.macros[dict.sid(c.ctx.cfg.ReplaceMacroTclDefaultDoubleRounding)]
 				}
 			case idTclIeeeDoubleRounding:
 				if c.ctx.cfg.ReplaceMacroTclIeeeDoubleRounding != "" {
 					m = c.macros[dict.sid(c.ctx.cfg.ReplaceMacroTclIeeeDoubleRounding)]
 				}
 			}
 			if m != nil {
 				// -------------------------------------------------- C
 				// return expand(subst(ts(T), {}, {}, HS \cup {T}, {}) • TS’ );
 				// trc("---- expand C")
 				hs := hideSet{nm: {}}
 				for k, v := range tok.hs {
 					hs[k] = v
 				}
 				os := cppTokensPool.Get().(*[]cppToken)
 				toks := c.subst(m, c.cppToks(m.repl), nil, nil, nil, hs, os, expandDefined)
 				for i := range toks {
 					toks[i].pos = tok.pos
 				}
 				if len(toks) == 1 {
 					toks[0].macro = nm
 				}
 				ts.ungets(toks)
 				(*os) = (*os)[:0]
 				cppTokensPool.Put(os)
 				goto start
 			}
 		}
 
 		if m != nil && m.isFnLike {
 			switch nm {
 			case idFdZero:
 				if c.ctx.cfg.ReplaceMacroFdZero != "" {
 					m = c.macros[dict.sid(c.ctx.cfg.ReplaceMacroFdZero)]
 				}
 			}
 			if m != nil {
 				// -------------------------------------------------- D
 				// check TS’ is actuals • )^HS’ • TS’’ and actuals are "correct for T"
 				// return expand(subst(ts(T), fp(T), actuals,(HS \cap HS’) \cup {T }, {}) • TS’’);
 				// trc("---- expand D")
 				hs := tok.hs
 				var skip []cppToken
 			again:
 				t2, ok := ts.read()
 				if !ok {
 					// dbg("expand write %q", tok)
 					w.write(tok)
 					ts.ungets(skip)
 					goto start
 				}
 
 				skip = append(skip, t2)
 				switch t2.char {
 				case '\n', ' ':
 					goto again
 				case '(':
 					// ok
 				default:
 					w.write(tok)
 					ts.ungets(skip)
 					goto start
 				}
 
 				varArgs, ap, hs2 := c.actuals(m, ts)
 				if nm == idHasIncludeImpl { //TODO-
 					if len(ap) != 1 || len(ap[0]) != 1 {
 						panic(todo("internal error"))
 					}
 
 					arg := ap[0][0].value.String()
 					switch {
 					case strings.HasPrefix(arg, `"\"`): // `"\"stdio.h\""`
 						arg = arg[2:len(arg)-3] + `"` // -> `"stdio.h"`
 					case strings.HasPrefix(arg, `"<`): // `"<stdio.h>"`
 						arg = arg[1 : len(arg)-1] // -> `<stdio.h>`
 					default:
 						arg = ""
 					}
 					var tok3 token3
 					tok3.char = PPNUMBER
 					tok3.value = idZero
 					if arg != "" {
 						if _, err := c.hasInclude(&tok, arg); err == nil {
 							tok3.value = idOne
 						}
 					}
 					tok := cppToken{token4{token3: tok3, file: c.file}, nil}
 					ts.ungets([]cppToken{tok})
 					goto start
 				}
 
 				switch {
 				case len(hs2) == 0:
 					hs2 = hideSet{nm: {}}
 				default:
 					nhs := hideSet{}
 					for k := range hs {
 						if _, ok := hs2[k]; ok {
 							nhs[k] = struct{}{}
 						}
 					}
 					nhs[nm] = struct{}{}
 					hs2 = nhs
 				}
 				os := cppTokensPool.Get().(*[]cppToken)
 				toks := c.subst(m, c.cppToks(m.repl), m.fp, varArgs, ap, hs2, os, expandDefined)
 				for i := range toks {
 					toks[i].pos = tok.pos
 				}
 				ts.ungets(toks)
 				(*os) = (*os)[:0]
 				cppTokensPool.Put(os)
 				goto start
 			}
 		}
 	}
 
 	// ------------------------------------------------------------------ E
 	// note TS must be T^HS • TS’
 	// return T^HS • expand(TS’);
 	// trc("---- expand E")
 	// trc("expand write %q", tok)
 	w.write(tok)
 	goto start
 }
 
 func (c *cpp) hasInclude(n Node, nm string) (rs string, err error) {
 	// nm0 := nm
 	// defer func() { //TODO-
 	// 	trc("nm0 %q nm %q rs %q err %v", nm0, nm, rs, err)
 	// }()
 	var (
 		b     byte
 		paths []string
 		sys   bool
 	)
 	switch {
 	case nm != "" && nm[0] == '"':
 		paths = c.ctx.includePaths
 		b = '"'
 	case nm != "" && nm[0] == '<':
 		paths = c.ctx.sysIncludePaths
 		sys = true
 		b = '>'
 	case nm == "":
 		return "", fmt.Errorf("%v: invalid empty include argument", n.Position())
 	default:
 		return "", fmt.Errorf("%v: invalid include argument %s", n.Position(), nm)
 	}
 
 	x := strings.IndexByte(nm[1:], b)
 	if x < 0 {
 		return "", fmt.Errorf("%v: invalid include argument %s", n.Position(), nm)
 	}
 
 	nm = filepath.FromSlash(nm[1 : x+1])
 	switch {
 	case filepath.IsAbs(nm):
 		fi, err := c.ctx.statFile(nm, sys)
 		if err != nil {
 			return "", fmt.Errorf("%v: %s", n.Position(), err)
 		}
 
 		if fi.IsDir() {
 			return "", fmt.Errorf("%v: %s is a directory, not a file", n.Position(), nm)
 		}
 
 		return nm, nil
 	default:
 		dir := filepath.Dir(c.file.Name())
 		for _, v := range paths {
 			if v == "@" {
 				v = dir
 			}
 
 			var p string
 			switch {
 			case strings.HasPrefix(nm, "./"):
 				wd := c.ctx.cfg.WorkingDir
 				if wd == "" {
 					var err error
 					if wd, err = os.Getwd(); err != nil {
 						return "", fmt.Errorf("%v: cannot determine working dir: %v", n.Position(), err)
 					}
 				}
 				p = filepath.Join(wd, nm)
 			default:
 				p = filepath.Join(v, nm)
 			}
 			fi, err := c.ctx.statFile(p, sys)
 			if err != nil || fi.IsDir() {
 				continue
 			}
 
 			return p, nil
 		}
 		wd, _ := os.Getwd()
 		return "", fmt.Errorf("include file not found: %s (wd %s)\nsearch paths:\n\t%s", nm, wd, strings.Join(paths, "\n\t"))
 	}
 }
 
 func (c *cpp) actuals(m *Macro, r tokenReader) (varArgs []cppToken, ap [][]cppToken, hs hideSet) {
 	var lvl, n int
 	varx := len(m.fp)
 	if m.namedVariadic {
 		varx--
 	}
 	var last rune
 	for {
 		t, ok := r.read()
 		if !ok {
 			c.err(t, "unexpected EOF")
 			return nil, nil, nil
 		}
 
 		// 6.10.3, 10
 		//
 		// Within the sequence of preprocessing tokens making up an
 		// invocation of a function-like macro, new-line is considered
 		// a normal white-space character.
 		if t.char == '\n' {
 			t.char = ' '
 			t.value = idSpace
 		}
 		if t.char == ' ' && last == ' ' {
 			continue
 		}
 
 		last = t.char
 		switch t.char {
 		case ',':
 			if lvl == 0 {
 				if n >= varx && (len(varArgs) != 0 || !isWhite(t.char)) {
 					varArgs = append(varArgs, t)
 				}
 				n++
 				continue
 			}
 		case ')':
 			if lvl == 0 {
 				for len(ap) < len(m.fp) {
 					ap = append(ap, nil)
 				}
 				for i, v := range ap {
 					ap[i] = c.trim(v)
 				}
 				// for i, v := range ap {
 				// 	dbg("%T.actuals %v/%v %q", c, i, len(ap), tokStr(v, "|"))
 				// }
 				return c.trim(varArgs), ap, t.hs
 			}
 			lvl--
 		case '(':
 			lvl++
 		}
 		if n >= varx && (len(varArgs) != 0 || !isWhite(t.char)) {
 			varArgs = append(varArgs, t)
 		}
 		for len(ap) <= n {
 			ap = append(ap, []cppToken{})
 		}
 		ap[n] = append(ap[n], t)
 	}
 }
 
 // [1]pg 2.
 //
 // subst(IS, FP, AP, HS, OS) /* substitute args, handle stringize and paste */
 // {
 // 	if IS is {} then
 //		// ---------------------------------------------------------- A
 // 		return hsadd(HS, OS);
 //
 // 	else if IS is # • T • IS’ and T is FP[i] then
 //		// ---------------------------------------------------------- B
 // 		return subst(IS’, FP, AP, HS, OS • stringize(select(i, AP)));
 //
 // 	else if IS is ## • T • IS’ and T is FP[i] then
 //	{
 //		// ---------------------------------------------------------- C
 // 		if select(i, AP) is {} then /* only if actuals can be empty */
 //			// -------------------------------------------------- D
 // 			return subst(IS’, FP, AP, HS, OS);
 // 		else
 //			// -------------------------------------------------- E
 // 			return subst(IS’, FP, AP, HS, glue(OS, select(i, AP)));
 // 	}
 //
 // 	else if IS is ## • T^HS’ • IS’ then
 //		// ---------------------------------------------------------- F
 // 		return subst(IS’, FP, AP, HS, glue(OS, T^HS’));
 //
 // 	else if IS is T • ##^HS’ • IS’ and T is FP[i] then
 //	{
 //		// ---------------------------------------------------------- G
 // 		if select(i, AP) is {} then /* only if actuals can be empty */
 //		{
 //			// -------------------------------------------------- H
 // 			if IS’ is T’ • IS’’ and T’ is FP[j] then
 //				// ------------------------------------------ I
 // 				return subst(IS’’, FP, AP, HS, OS • select(j, AP));
 // 			else
 //				// ------------------------------------------ J
 // 				return subst(IS’, FP, AP, HS, OS);
 // 		}
 //		else
 //			// -------------------------------------------------- K
 // 			return subst(##^HS’ • IS’, FP, AP, HS, OS • select(i, AP));
 //
 //	}
 //
 // 	else if IS is T • IS’ and T is FP[i] then
 //		// ---------------------------------------------------------- L
 // 		return subst(IS’, FP, AP, HS, OS • expand(select(i, AP)));
 //
 //	// ------------------------------------------------------------------ M
 // 	note IS must be T^HS’ • IS’
 // 	return subst(IS’, FP, AP, HS, OS • T^HS’);
 // }
 //
 // A quick overview of subst is that it walks through the input sequence, IS,
 // building up an output sequence, OS, by handling each token from left to
 // right. (The order that this operation takes is left to the implementation
 // also, walking from left to right is more natural since the rest of the
 // algorithm is constrained to this ordering.) Stringizing is easy, pasting
 // requires trickier handling because the operation has a bunch of
 // combinations. After the entire input sequence is finished, the updated hide
 // set is applied to the output sequence, and that is the result of subst.
 func (c *cpp) subst(m *Macro, is []cppToken, fp []StringID, varArgs []cppToken, ap [][]cppToken, hs hideSet, os *[]cppToken, expandDefined bool) (r []cppToken) {
 	var ap0 [][]cppToken
 	for _, v := range ap {
 		ap0 = append(ap0, append([]cppToken(nil), v...))
 	}
 	// trc("==== subst: is %q, fp, %v ap@%p %v", cppToksStr(is, "|"), fp, &ap, cppToksStr2(ap))
 start:
 	// trc("start: is %q, fp %v, ap@%p %v, os %q", cppToksStr(is, "|"), fp, &ap, cppToksStr2(ap), cppToksStr(*os, "|"))
 	if len(is) == 0 {
 		// ---------------------------------------------------------- A
 		// return hsadd(HS, OS);
 		// trc("---- A")
 		// trc("subst RETURNS %q", cppToksStr(*os, "|"))
 		return c.hsAdd(hs, os)
 	}
 
 	tok := is[0]
 	var arg []cppToken
 	if tok.char == '#' {
 		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap0, is[1].value, &arg) {
 			// -------------------------------------------------- B
 			// return subst(IS’, FP, AP, HS, OS • stringize(select(i, AP)));
 			// trc("---- subst B")
 			*os = append(*os, c.stringize(arg))
 			is = is[2:]
 			goto start
 		}
 	}
 
 	if tok.char == PPPASTE {
 		if len(is) > 1 && is[1].char == IDENTIFIER && m.param(varArgs, ap0, is[1].value, &arg) {
 			// -------------------------------------------------- C
 			// trc("---- subst C")
 			if len(arg) == 0 {
 				// TODO "only if actuals can be empty"
 				// ------------------------------------------ D
 				// return subst(IS’, FP, AP, HS, OS);
 				// trc("---- D")
 				if c := len(*os); c != 0 && (*os)[c-1].char == ',' {
 					*os = (*os)[:c-1]
 				}
 				is = is[2:]
 				goto start
 			}
 
 			// -------------------------------------------------- E
 			// return subst(IS’, FP, AP, HS, glue(OS, select(i, AP)));
 			// trc("---- subst E, arg %q", cppToksStr(arg, "|"))
 			*os = c.glue(*os, arg)
 			is = is[2:]
 			goto start
 		}
 
 		if len(is) > 1 {
 			// -------------------------------------------------- F
 			// return subst(IS’, FP, AP, HS, glue(OS, T^HS’));
 			// trc("---- subst F")
 			*os = c.glue(*os, is[1:2])
 			is = is[2:]
 			goto start
 		}
 	}
 
 	if tok.char == IDENTIFIER && (len(is) > 1 && is[1].char == PPPASTE) && m.param(varArgs, ap0, tok.value, &arg) {
 		// ---------------------------------------------------------- G
 		// trc("---- subst G")
 		if len(arg) == 0 {
 			// TODO "only if actuals can be empty"
 			// -------------------------------------------------- H
 			// trc("---- subst H")
 			is = is[2:] // skip T##
 			if len(is) > 0 && is[0].char == IDENTIFIER && m.param(varArgs, ap, is[0].value, &arg) {
 				// -------------------------------------------------- I
 				// return subst(IS’’, FP, AP, HS, OS • select(j, AP));
 				// trc("---- subst I")
 				*os = append(*os, arg...)
 				is = is[1:]
 				goto start
 			} else {
 				// -------------------------------------------------- J
 				// return subst(IS’, FP, AP, HS, OS);
 				// trc("---- subst J")
 				goto start
 			}
 		}
 
 		// ---------------------------------------------------------- K
 		// return subst(##^HS’ • IS’, FP, AP, HS, OS • select(i, AP));
 		// trc("---- subst K")
 		*os = append(*os, arg...)
 		is = is[1:]
 		goto start
 	}
 
 	ax := -1
 	if tok.char == IDENTIFIER && m.param2(varArgs, ap, tok.value, &arg, &ax) {
 		// ------------------------------------------ L
 		// return subst(IS’, FP, AP, HS, OS • expand(select(i, AP)));
 		// trc("---- subst L")
 		// if toks, ok := cache[tok.value]; ok {
 		// 	os = append(os, toks...)
 		// 	is = is[1:]
 		// 	goto start
 		// }
 
 		sel := cppReader{buf: arg}
 		var w cppWriter
 		// trc("---- L(1) ap@%p %v", &ap, cppToksStr2(ap))
 		c.expand(&sel, &w, expandDefined)
 		// trc("---- L(2) ap@%p %v", &ap, cppToksStr2(ap))
 		*os = append(*os, w.toks...)
 		if ax >= 0 {
 			ap[ax] = w.toks
 		}
 		is = is[1:]
 		goto start
 	}
 
 	// ------------------------------------------------------------------ M
 	// note IS must be T^HS’ • IS’
 	// return subst(IS’, FP, AP, HS, OS • T^HS’);
 	*os = append(*os, tok)
 	is = is[1:]
 	// trc("---- subst M: is %q, os %q", cppToksStr(is, "|"), cppToksStr(*os, "|"))
 	goto start
 }
 
 // paste last of left side with first of right side
 //
 // [1] pg. 3
 //
 //TODO implement properly [0], 6.10.3.3, 2. Must rescan the resulting token(s).
 //
 // $ cat main.c
 // #include <stdio.h>
 //
 // #define foo(a, b) a ## b
 //
 // int main() {
 // 	int i = 42;
 // 	i foo(+, +);
 // 	printf("%i\n", i);
 // 	return 0;
 // }
 // $ rm -f a.out ; gcc -Wall main.c && ./a.out ; echo $?
 // 43
 // 0
 // $
 //
 // ----------------------------------------------------------------------------
 //	glue(LS,RS ) /* paste last of left side with first of right side */
 //	{
 //		if LS is L^HS and RS is R^HS’ • RS’ then
 //			return L&R^(HS∩HS’) • RS’;	/* undefined if L&R is invalid */
 
 //		// note LS must be L HS • LS’
 //		return L^HS • glue(LS’,RS );
 //	}
 func (c *cpp) glue(ls, rs []cppToken) (out []cppToken) {
 	// trc("ls %q, rs %q", cppToksStr(ls, "|"), cppToksStr(rs, "|"))
 	if len(rs) == 0 {
 		return ls
 	}
 
 	if len(ls) == 0 {
 		return rs
 	}
 
 	l := ls[len(ls)-1]
 	ls = ls[:len(ls)-1]
 	r := rs[0]
 	rs = rs[1:]
 
 	if l.char == IDENTIFIER && l.value == idL && r.char == STRINGLITERAL {
 		l.char = LONGSTRINGLITERAL
 	}
 	l.value = dict.sid(l.String() + r.String())
 	return append(append(ls, l), rs...)
 }
 
 // Given a token sequence, stringize returns a single string literal token
 // containing the concatenated spellings of the tokens.
 //
 // [1] pg. 3
 func (c *cpp) stringize(s0 []cppToken) (r cppToken) {
 	// 6.10.3.2
 	//
 	// Each occurrence of white space between the argument’s preprocessing
 	// tokens becomes a single space character in the character string
 	// literal.
 	s := make([]cppToken, 0, len(s0))
 	var last rune
 	for i := range s0 {
 		t := s0[i]
 		if isWhite(t.char) {
 			t.char = ' '
 			t.value = idSpace
 			if last == ' ' {
 				continue
 			}
 		}
 
 		last = t.char
 		s = append(s, t)
 	}
 
 	// White space before the first preprocessing token and after the last
 	// preprocessing token composing the argument is deleted.
 	s = c.trim(s)
 
 	// The character string literal corresponding to an empty argument is
 	// ""
 	if len(s) == 0 {
 		r.hs = nil
 		r.char = STRINGLITERAL
 		r.value = idEmptyString
 		return r
 	}
 
 	var a []string
 	// Otherwise, the original spelling of each preprocessing token in the
 	// argument is retained in the character string literal, except for
 	// special handling for producing the spelling of string literals and
 	// character constants: a \ character is inserted before each " and \
 	// character of a character constant or string literal (including the
 	// delimiting " characters), except that it is implementation-defined
 	// whether a \ character is inserted before the \ character beginning a
 	// universal character name.
 	for _, v := range s {
 		s := v.String()
 		switch v.char {
 		case CHARCONST, STRINGLITERAL:
 			s = strings.ReplaceAll(s, `\`, `\\`)
 			s = strings.ReplaceAll(s, `"`, `\"`)
 		case LONGCHARCONST, LONGSTRINGLITERAL:
 			panic("TODO")
 		}
 		a = append(a, s)
 	}
 	r = s[0]
 	r.hs = nil
 	r.char = STRINGLITERAL
 	r.value = dict.sid(`"` + strings.Join(a, "") + `"`)
 	return r
 }
 
 func (c *cpp) trim(toks []cppToken) []cppToken {
 	for len(toks) != 0 && isWhite(toks[0].char) {
 		toks = toks[1:]
 	}
 	for len(toks) != 0 && isWhite(toks[len(toks)-1].char) {
 		toks = toks[:len(toks)-1]
 	}
 	return toks
 }
 
 func (c *cpp) hsAdd(hs hideSet, toks *[]cppToken) []cppToken {
 	for i, v := range *toks {
 		if v.hs == nil {
 			v.hs = hideSet{}
 		}
 		for k, w := range hs {
 			v.hs[k] = w
 		}
 		v.file = c.file
 		(*toks)[i] = v
 	}
 	return *toks
 }
 
 func (c *cpp) parseDefined(tok cppToken, r tokenReader, w tokenWriter) {
 	toks := []cppToken{tok}
 	if tok = c.scanToNonBlankToken(&toks, r, w); tok.char < 0 {
 		return
 	}
 
 	switch tok.char {
 	case IDENTIFIER:
 		// ok
 	case '(':
 		if tok = c.scanToNonBlankToken(&toks, r, w); tok.char < 0 {
 			return
 		}
 
 		if tok.char != IDENTIFIER {
 			w.writes(toks)
 			return
 		}
 
 		tok2 := c.scanToNonBlankToken(&toks, r, w)
 		if tok2.char < 0 {
 			return
 		}
 
 		if tok2.char != ')' {
 			w.writes(toks)
 			return
 		}
 	}
 
 	tok.char = PPNUMBER
 	switch _, ok := c.macros[tok.value]; {
 	case ok:
 		tok.value = idOne
 	default:
 		tok.value = idZero
 	}
 	w.write(tok)
 }
 
 func (c *cpp) scanToNonBlankToken(toks *[]cppToken, r tokenReader, w tokenWriter) cppToken {
 	tok, ok := r.read()
 	if !ok {
 		w.writes(*toks)
 		tok.char = -1
 		return tok
 	}
 
 	*toks = append(*toks, tok)
 	if tok.char == ' ' || tok.char == '\n' {
 		if tok, ok = r.read(); !ok {
 			w.writes(*toks)
 			tok.char = -1
 			return tok
 		}
 
 		*toks = append(*toks, tok)
 	}
 	return (*toks)[len(*toks)-1]
 }
 
 // [0], 6.10.1
 func (c *cpp) evalInclusionCondition(expr []token3) (r bool) {
 	if !c.intmaxChecked {
 		if m := c.macros[idIntMaxWidth]; m != nil && len(m.repl) != 0 {
 			if val := c.intMaxWidth(); val != 0 && val != 64 {
 				c.err(m.name, "%s is %v, but only 64 is supported", idIntMaxWidth, val)
 			}
 		}
 		c.intmaxChecked = true
 	}
 
 	val := c.eval(expr)
 	return val != nil && c.isNonZero(val)
 }
 
 func (c *cpp) intMaxWidth() int64 {
 	if m := c.macros[idIntMaxWidth]; m != nil && len(m.repl) != 0 {
 		switch x := c.eval(m.repl).(type) {
 		case nil:
 			return 0
 		case int64:
 			return x
 		case uint64:
 			return int64(x)
 		default:
 			panic(internalError())
 		}
 	}
 	return 0
 }
 
 func (c *cpp) eval(expr []token3) interface{} {
 	toks := make([]cppToken, len(expr))
 	for i, v := range expr {
 		toks[i] = cppToken{token4{token3: v}, nil}
 	}
 	var w cppWriter
 	c.expand(&cppReader{buf: toks}, &w, true)
 	toks = w.toks
 	p := 0
 	for _, v := range toks {
 		switch v.char {
 		case ' ', '\n':
 			// nop
 		default:
 			toks[p] = v
 			p++
 		}
 	}
 	toks = toks[:p]
 	s := cppScanner(toks)
 	val := c.expression(&s, true)
 	switch s.peek().char {
 	case -1, '#':
 		// ok
 	default:
 		t := s.peek()
 		c.err(t, "unexpected %s", tokName(t.char))
 		return nil
 	}
 	return val
 }
 
 // [0], 6.5.17 Comma operator
 //
 //  expression:
 // 	assignment-expression
 // 	expression , assignment-expression
 func (c *cpp) expression(s *cppScanner, eval bool) interface{} {
 	for {
 		r := c.assignmentExpression(s, eval)
 		if s.peek().char != ',' {
 			return r
 		}
 
 		s.next()
 	}
 }
 
 // [0], 6.5.16 Assignment operators
 //
 //  assignment-expression:
 // 	conditional-expression
 // 	unary-expression assignment-operator assignment-expression
 //
 //  assignment-operator: one of
 // 	= *= /= %= += -= <<= >>= &= ^= |=
 func (c *cpp) assignmentExpression(s *cppScanner, eval bool) interface{} {
 	return c.conditionalExpression(s, eval)
 }
 
 // [0], 6.5.15 Conditional operator
 //
 //  conditional-expression:
 //		logical-OR-expression
 //		logical-OR-expression ? expression : conditional-expression
 func (c *cpp) conditionalExpression(s *cppScanner, eval bool) interface{} {
 	expr := c.logicalOrExpression(s, eval)
 	if s.peek().char == '?' {
 		s.next()
 		exprIsNonZero := c.isNonZero(expr)
 		expr2 := c.conditionalExpression(s, exprIsNonZero)
 		if tok := s.peek(); tok.char != ':' {
 			c.err(tok, "expected ':'")
 			return expr
 		}
 
 		s.next()
 		expr3 := c.conditionalExpression(s, !exprIsNonZero)
 
 		// [0] 6.5.15
 		//
 		// 5. If both the second and third operands have arithmetic type, the result
 		// type that would be determined by the usual arithmetic conversions, were they
 		// applied to those two operands, is the type of the result.
 		x := c.operand(expr2)
 		y := c.operand(expr3)
 		if x != nil && y != nil {
 			x, y = usualArithmeticConversions(c.ctx, nil, x, y, false)
 			expr2 = c.fromOperand(x)
 			expr3 = c.fromOperand(y)
 		}
 
 		switch {
 		case exprIsNonZero:
 			expr = expr2
 		default:
 			expr = expr3
 		}
 	}
 	return expr
 }
 
 func (c *cpp) operand(v interface{}) Operand {
 	switch x := v.(type) {
 	case int64:
 		return &operand{typ: &typeBase{size: 8, kind: byte(LongLong), flags: fSigned}, value: Int64Value(x)}
 	case uint64:
 		return &operand{typ: &typeBase{size: 8, kind: byte(ULongLong)}, value: Uint64Value(x)}
 	default:
 		return nil
 	}
 }
 
 func (c *cpp) fromOperand(op Operand) interface{} {
 	switch x := op.Value().(type) {
 	case Int64Value:
 		return int64(x)
 	case Uint64Value:
 		return uint64(x)
 	default:
 		return nil
 	}
 }
 
 // [0], 6.5.14 Logical OR operator
 //
 //  logical-OR-expression:
 //		logical-AND-expression
 //		logical-OR-expression || logical-AND-expression
 func (c *cpp) logicalOrExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.logicalAndExpression(s, eval)
 	for s.peek().char == OROR {
 		s.next()
 		if c.isNonZero(lhs) {
 			eval = false
 		}
 		rhs := c.logicalAndExpression(s, eval)
 		if c.isNonZero(lhs) || c.isNonZero(rhs) {
 			lhs = int64(1)
 		}
 	}
 	return lhs
 }
 
 // [0], 6.5.13 Logical AND operator
 //
 //  logical-AND-expression:
 //		inclusive-OR-expression
 //		logical-AND-expression && inclusive-OR-expression
 func (c *cpp) logicalAndExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.inclusiveOrExpression(s, eval)
 	for s.peek().char == ANDAND {
 		s.next()
 		if c.isZero(lhs) {
 			eval = false
 		}
 		rhs := c.inclusiveOrExpression(s, eval)
 		if c.isZero(lhs) || c.isZero(rhs) {
 			lhs = int64(0)
 		}
 	}
 	return lhs
 }
 
 func (c *cpp) isZero(val interface{}) bool {
 	switch x := val.(type) {
 	case int64:
 		return x == 0
 	case uint64:
 		return x == 0
 	}
 	panic(internalError())
 }
 
 // [0], 6.5.12 Bitwise inclusive OR operator
 //
 //  inclusive-OR-expression:
 //		exclusive-OR-expression
 //		inclusive-OR-expression | exclusive-OR-expression
 func (c *cpp) inclusiveOrExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.exclusiveOrExpression(s, eval)
 	for s.peek().char == '|' {
 		s.next()
 		rhs := c.exclusiveOrExpression(s, eval)
 		if eval {
 			switch x := lhs.(type) {
 			case int64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x | y
 				case uint64:
 					lhs = uint64(x) | y
 				}
 			case uint64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x | uint64(y)
 				case uint64:
 					lhs = x | y
 				}
 			}
 		}
 	}
 	return lhs
 }
 
 // [0], 6.5.11 Bitwise exclusive OR operator
 //
 //  exclusive-OR-expression:
 //		AND-expression
 //		exclusive-OR-expression ^ AND-expression
 func (c *cpp) exclusiveOrExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.andExpression(s, eval)
 	for s.peek().char == '^' {
 		s.next()
 		rhs := c.andExpression(s, eval)
 		if eval {
 			switch x := lhs.(type) {
 			case int64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x ^ y
 				case uint64:
 					lhs = uint64(x) ^ y
 				}
 			case uint64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x ^ uint64(y)
 				case uint64:
 					lhs = x ^ y
 				}
 			}
 		}
 	}
 	return lhs
 }
 
 // [0], 6.5.10 Bitwise AND operator
 //
 //  AND-expression:
 // 		equality-expression
 // 		AND-expression & equality-expression
 func (c *cpp) andExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.equalityExpression(s, eval)
 	for s.peek().char == '&' {
 		s.next()
 		rhs := c.equalityExpression(s, eval)
 		if eval {
 			switch x := lhs.(type) {
 			case int64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x & y
 				case uint64:
 					lhs = uint64(x) & y
 				}
 			case uint64:
 				switch y := rhs.(type) {
 				case int64:
 					lhs = x & uint64(y)
 				case uint64:
 					lhs = x & y
 				}
 			}
 		}
 	}
 	return lhs
 }
 
 // [0], 6.5.9 Equality operators
 //
 //  equality-expression:
 //		relational-expression
 //		equality-expression == relational-expression
 //		equality-expression != relational-expression
 func (c *cpp) equalityExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.relationalExpression(s, eval)
 	for {
 		var v bool
 		switch s.peek().char {
 		case EQ:
 			s.next()
 			rhs := c.relationalExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x == y
 					case uint64:
 						v = uint64(x) == y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x == uint64(y)
 					case uint64:
 						v = x == y
 					}
 				}
 			}
 		case NEQ:
 			s.next()
 			rhs := c.relationalExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x != y
 					case uint64:
 						v = uint64(x) != y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x != uint64(y)
 					case uint64:
 						v = x != y
 					}
 				}
 			}
 		default:
 			return lhs
 		}
 		switch {
 		case v:
 			lhs = int64(1)
 		default:
 			lhs = int64(0)
 		}
 	}
 }
 
 // [0], 6.5.8 Relational operators
 //
 //  relational-expression:
 //		shift-expression
 //		relational-expression <  shift-expression
 //		relational-expression >  shift-expression
 //		relational-expression <= shift-expression
 //		relational-expression >= shift-expression
 func (c *cpp) relationalExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.shiftExpression(s, eval)
 	for {
 		var v bool
 		switch s.peek().char {
 		case '<':
 			s.next()
 			rhs := c.shiftExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x < y
 					case uint64:
 						v = uint64(x) < y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x < uint64(y)
 					case uint64:
 						v = x < y
 					}
 				}
 			}
 		case '>':
 			s.next()
 			rhs := c.shiftExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x > y
 					case uint64:
 						v = uint64(x) > y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x > uint64(y)
 					case uint64:
 						v = x > y
 					}
 				}
 			}
 		case LEQ:
 			s.next()
 			rhs := c.shiftExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x <= y
 					case uint64:
 						v = uint64(x) <= y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x <= uint64(y)
 					case uint64:
 						v = x <= y
 					}
 				}
 			}
 		case GEQ:
 			s.next()
 			rhs := c.shiftExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x >= y
 					case uint64:
 						v = uint64(x) >= y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						v = x >= uint64(y)
 					case uint64:
 						v = x >= y
 					}
 				}
 			}
 		default:
 			return lhs
 		}
 		switch {
 		case v:
 			lhs = int64(1)
 		default:
 			lhs = int64(0)
 		}
 	}
 }
 
 // [0], 6.5.7 Bitwise shift operators
 //
 //  shift-expression:
 //		additive-expression
 //		shift-expression << additive-expression
 //		shift-expression >> additive-expression
 func (c *cpp) shiftExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.additiveExpression(s, eval)
 	for {
 		switch s.peek().char {
 		case LSH:
 			s.next()
 			rhs := c.additiveExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x << uint(y)
 					case uint64:
 						lhs = uint64(x) << uint(y)
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x << uint(y)
 					case uint64:
 						lhs = x << uint(y)
 					}
 				}
 			}
 		case RSH:
 			s.next()
 			rhs := c.additiveExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x >> uint(y)
 					case uint64:
 						lhs = uint64(x) >> uint(y)
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x >> uint(y)
 					case uint64:
 						lhs = x >> uint(y)
 					}
 				}
 			}
 		default:
 			return lhs
 		}
 	}
 }
 
 // [0], 6.5.6 Additive operators
 //
 //  additive-expression:
 //		multiplicative-expression
 //		additive-expression + multiplicative-expression
 //		additive-expression - multiplicative-expression
 func (c *cpp) additiveExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.multiplicativeExpression(s, eval)
 	for {
 		switch s.peek().char {
 		case '+':
 			s.next()
 			rhs := c.multiplicativeExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x + y
 					case uint64:
 						lhs = uint64(x) + y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x + uint64(y)
 					case uint64:
 						lhs = x + y
 					}
 				}
 			}
 		case '-':
 			s.next()
 			rhs := c.multiplicativeExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x - y
 					case uint64:
 						lhs = uint64(x) - y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x - uint64(y)
 					case uint64:
 						lhs = x - y
 					}
 				}
 			}
 		default:
 			return lhs
 		}
 	}
 }
 
 // [0], 6.5.5 Multiplicative operators
 //
 //  multiplicative-expression:
 //		unary-expression // [0], 6.10.1, 1.
 //		multiplicative-expression * unary-expression
 //		multiplicative-expression / unary-expression
 //		multiplicative-expression % unary-expression
 func (c *cpp) multiplicativeExpression(s *cppScanner, eval bool) interface{} {
 	lhs := c.unaryExpression(s, eval)
 	for {
 		switch s.peek().char {
 		case '*':
 			s.next()
 			rhs := c.unaryExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x * y
 					case uint64:
 						lhs = uint64(x) * y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						lhs = x * uint64(y)
 					case uint64:
 						lhs = x * y
 					}
 				}
 			}
 		case '/':
 			tok := s.next()
 			rhs := c.unaryExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x / y
 					case uint64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = uint64(x) / y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x / uint64(y)
 					case uint64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x / y
 					}
 				}
 			}
 		case '%':
 			tok := s.next()
 			rhs := c.unaryExpression(s, eval)
 			if eval {
 				switch x := lhs.(type) {
 				case int64:
 					switch y := rhs.(type) {
 					case int64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x % y
 					case uint64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = uint64(x) % y
 					}
 				case uint64:
 					switch y := rhs.(type) {
 					case int64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x % uint64(y)
 					case uint64:
 						if y == 0 {
 							c.err(tok, "division by zero")
 							break
 						}
 
 						lhs = x % y
 					}
 				}
 			}
 		default:
 			return lhs
 		}
 	}
 }
 
 // [0], 6.5.3 Unary operators
 //
 //  unary-expression:
 //		primary-expression
 //		unary-operator unary-expression
 //
 //  unary-operator: one of
 //		+ - ~ !
 func (c *cpp) unaryExpression(s *cppScanner, eval bool) interface{} {
 	switch s.peek().char {
 	case '+':
 		s.next()
 		return c.unaryExpression(s, eval)
 	case '-':
 		s.next()
 		expr := c.unaryExpression(s, eval)
 		if eval {
 			switch x := expr.(type) {
 			case int64:
 				expr = -x
 			case uint64:
 				expr = -x
 			}
 		}
 		return expr
 	case '~':
 		s.next()
 		expr := c.unaryExpression(s, eval)
 		if eval {
 			switch x := expr.(type) {
 			case int64:
 				expr = ^x
 			case uint64:
 				expr = ^x
 			}
 		}
 		return expr
 	case '!':
 		s.next()
 		expr := c.unaryExpression(s, eval)
 		if eval {
 			var v bool
 			switch x := expr.(type) {
 			case int64:
 				v = x == 0
 			case uint64:
 				v = x == 0
 			}
 			switch {
 			case v:
 				expr = int64(1)
 			default:
 				expr = int64(0)
 			}
 		}
 		return expr
 	default:
 		return c.primaryExpression(s, eval)
 	}
 }
 
 // [0], 6.5.1 Primary expressions
 //
 //  primary-expression:
 //		identifier
 //		constant
 //		( expression )
 func (c *cpp) primaryExpression(s *cppScanner, eval bool) interface{} {
 	switch tok := s.peek(); tok.char {
 	case CHARCONST, LONGCHARCONST:
 		s.next()
 		r := charConst(c.ctx, tok)
 		return int64(r)
 	case IDENTIFIER:
 		if c.ctx.evalIdentError {
 			panic("cannot evaluate identifier")
 		}
 
 		s.next()
 		if s.peek().char == '(' {
 			s.next()
 			n := 1
 		loop:
 			for n != 0 {
 				switch s.peek().char {
 				case '(':
 					n++
 				case ')':
 					n--
 				case -1:
 					c.err(s.peek(), "expected )")
 					break loop
 				}
 				s.next()
 			}
 		}
 		return int64(0)
 	case PPNUMBER:
 		s.next()
 		return c.intConst(tok)
 	case '(':
 		s.next()
 		expr := c.expression(s, eval)
 		if s.peek().char == ')' {
 			s.next()
 		}
 		return expr
 	default:
 		return int64(0)
 	}
 }
 
 // [0], 6.4.4.1 Integer constants
 //
 //  integer-constant:
 //		decimal-constant integer-suffix_opt
 //		octal-constant integer-suffix_opt
 //		hexadecimal-constant integer-suffix_opt
 //
 //  decimal-constant:
 //		nonzero-digit
 //		decimal-constant digit
 //
 //  octal-constant:
 //		0
 //		octal-constant octal-digit
 //
 //  hexadecimal-prefix: one of
 //		0x 0X
 //
 //  integer-suffix_opt: one of
 //		u ul ull l lu ll llu
 func (c *cpp) intConst(tok cppToken) (r interface{}) {
 	var n uint64
 	s0 := tok.String()
 	s := strings.TrimRight(s0, "uUlL")
 	switch {
 	case strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X"):
 		var err error
 		if n, err = strconv.ParseUint(s[2:], 16, 64); err != nil {
 			c.err(tok, "%v", err)
 			return int64(0)
 		}
 	case strings.HasPrefix(s, "0"):
 		var err error
 		if n, err = strconv.ParseUint(s, 8, 64); err != nil {
 			c.err(tok, "%v", err)
 			return int64(0)
 		}
 	default:
 		var err error
 		if n, err = strconv.ParseUint(s, 10, 64); err != nil {
 			c.err(tok, "%v", err)
 			return int64(0)
 		}
 	}
 
 	suffix := s0[len(s):]
 	if suffix == "" {
 		if n > math.MaxInt64 {
 			return n
 		}
 
 		return int64(n)
 	}
 
 	switch suffix = strings.ToLower(suffix); suffix {
 	default:
 		c.err(tok, "invalid suffix: %v", s0)
 		fallthrough
 	case
 		"l",
 		"ll":
 
 		if n > math.MaxInt64 {
 			return n
 		}
 
 		return int64(n)
 	case
 		"llu",
 		"lu",
 		"u",
 		"ul",
 		"ull":
 
 		return n
 	}
 }
 
 func charConst(ctx *context, tok cppToken) rune {
 	s := tok.String()
 	switch tok.char {
 	case LONGCHARCONST:
 		s = s[1:] // Remove leading 'L'.
 		fallthrough
 	case CHARCONST:
 		s = s[1 : len(s)-1] // Remove outer 's.
 		if len(s) == 1 {
 			return rune(s[0])
 		}
 
 		var r rune
 		var n int
 		switch s[0] {
 		case '\\':
 			r, n = decodeEscapeSequence(ctx, tok, s)
 			if r < 0 {
 				r = -r
 			}
 		default:
 			r, n = utf8.DecodeRuneInString(s)
 		}
 		if n != len(s) {
 			ctx.errNode(&tok, "invalid character constant")
 		}
 		return r
 	}
 	panic(internalError())
 }
 
 // escape-sequence		{simple-sequence}|{octal-escape-sequence}|{hexadecimal-escape-sequence}|{universal-character-name}
 // simple-sequence		\\['\x22?\\abfnrtv]
 // octal-escape-sequence	\\{octal-digit}{octal-digit}?{octal-digit}?
 // hexadecimal-escape-sequence	\\x{hexadecimal-digit}+
 func decodeEscapeSequence(ctx *context, tok cppToken, s string) (rune, int) {
 	if s[0] != '\\' {
 		panic(internalError())
 	}
 
 	if len(s) == 1 {
 		return rune(s[0]), 1
 	}
 
 	r := rune(s[1])
 	switch r {
 	case '\'', '"', '?', '\\':
 		return r, 2
 	case 'a':
 		return 7, 2
 	case 'b':
 		return 8, 2
 	case 'e':
 		return 0x1b, 2
 	case 'f':
 		return 12, 2
 	case 'n':
 		return 10, 2
 	case 'r':
 		return 13, 2
 	case 't':
 		return 9, 2
 	case 'v':
 		return 11, 2
 	case 'x':
 		v, n := 0, 2
 	loop2:
 		for i := 2; i < len(s); i++ {
 			r := s[i]
 			switch {
 			case r >= '0' && r <= '9', r >= 'a' && r <= 'f', r >= 'A' && r <= 'F':
 				v = v<<4 | decodeHex(r)
 				n++
 			default:
 				break loop2
 			}
 		}
 		return -rune(v & 0xff), n
 	case 'u', 'U':
 		return decodeUCN(s)
 	}
 
 	if r < '0' || r > '7' {
 		panic(internalError())
 	}
 
 	v, n := 0, 1
 	ok := false
 loop:
 	for i := 1; i < len(s); i++ {
 		r := s[i]
 		switch {
 		case i < 4 && r >= '0' && r <= '7':
 			ok = true
 			v = v<<3 | (int(r) - '0')
 			n++
 		default:
 			break loop
 		}
 	}
 	if !ok {
 		ctx.errNode(&tok, "invalid octal sequence")
 	}
 	return -rune(v), n
 }
 
 // universal-character-name	\\u{hex-quad}|\\U{hex-quad}{hex-quad}
 func decodeUCN(s string) (rune, int) {
 	if s[0] != '\\' {
 		panic(internalError())
 	}
 
 	s = s[1:]
 	switch s[0] {
 	case 'u':
 		return rune(decodeHexQuad(s[1:])), 6
 	case 'U':
 		return rune(decodeHexQuad(s[1:])<<16 | decodeHexQuad(s[5:])), 10
 	}
 	panic(internalError())
 }
 
 // hex-quad	{hexadecimal-digit}{hexadecimal-digit}{hexadecimal-digit}{hexadecimal-digit}
 func decodeHexQuad(s string) int {
 	n := 0
 	for i := 0; i < 4; i++ {
 		n = n<<4 | decodeHex(s[i])
 	}
 	return n
 }
 
 func decodeHex(r byte) int {
 	switch {
 	case r >= '0' && r <= '9':
 		return int(r) - '0'
 	default:
 		x := int(r) &^ 0x20
 		return x - 'A' + 10
 	}
 }
 
 func (c *cpp) isNonZero(val interface{}) bool {
 	switch x := val.(type) {
 	case int64:
 		return x != 0
 	case uint64:
 		return x != 0
 	}
 	panic(internalError())
 }
 
 type ppLine interface {
 	getToks() []token3
 }
 
 type ppIfGroupDirective interface {
 	evalInclusionCondition(*cpp) bool
 }
 
 type ppElifDirective struct {
 	toks []token3
 	expr []token3
 }
 
 func (n *ppElifDirective) getToks() []token3 { return n.toks }
 
 type ppElseDirective struct {
 	toks []token3
 }
 
 func (n *ppElseDirective) getToks() []token3 { return n.toks }
 
 type ppEndifDirective struct {
 	toks []token3
 }
 
 func (n *ppEndifDirective) getToks() []token3 { return n.toks }
 
 type ppEmptyDirective struct {
 	toks []token3
 }
 
 func (n *ppEmptyDirective) getToks() []token3 { return n.toks }
 
 func (n *ppEmptyDirective) translationPhase4(c *cpp) {
 	// nop
 }
 
 type ppIncludeDirective struct {
 	arg  []token3
 	toks []token3
 
 	includeNext bool // false: #include, true: #include_next
 }
 
 func (n *ppIncludeDirective) getToks() []token3 { return n.toks }
 
 func (n *ppIncludeDirective) translationPhase4(c *cpp) {
 	if c.ctx.cfg.ignoreIncludes {
 		return
 	}
 
 	args := make([]cppToken, 0, len(n.arg))
 	for _, v := range n.arg {
 		switch v.char {
 		case ' ', '\t', '\v', '\f':
 			// nop
 		default:
 			args = append(args, cppToken{token4{token3: v}, nil})
 		}
 	}
 	var sb strings.Builder
 	for _, v := range args {
 		sb.WriteString(v.String())
 	}
 	nm := strings.TrimSpace(sb.String())
 	if nm == "" {
 		c.err(n.toks[0], "invalid empty include argument")
 		return
 	}
 
 	switch nm[0] {
 	case '"', '<':
 		// ok
 	default:
 		var w cppWriter
 		c.expand(&cppReader{buf: args}, &w, false)
 		x := 0
 		for _, v := range w.toks {
 			switch v.char {
 			case ' ', '\t', '\v', '\f':
 				// nop
 			default:
 				w.toks[x] = v
 				x++
 			}
 		}
 		w.toks = w.toks[:x]
 		nm = strings.TrimSpace(cppToksStr(w.toks, ""))
 	}
 	toks := n.toks
 	if c.ctx.cfg.RejectIncludeNext {
 		c.err(toks[0], "#include_next is a GCC extension")
 		return
 	}
 
 	if c.ctx.cfg.fakeIncludes {
 		c.send([]token3{{char: STRINGLITERAL, value: dict.sid(nm), src: dict.sid(nm)}, {char: '\n', value: idNL}})
 		return
 	}
 
 	if re := c.ctx.cfg.IgnoreInclude; re != nil && re.MatchString(nm) {
 		return
 	}
 
 	if c.includeLevel == maxIncludeLevel {
 		c.err(toks[0], "too many include levels")
 		return
 	}
 
 	c.includeLevel++
 
 	defer func() { c.includeLevel-- }()
 
 	var (
 		b     byte
 		paths []string
 		sys   bool
 	)
 	switch {
 	case nm != "" && nm[0] == '"':
 		paths = c.ctx.includePaths
 		b = '"'
 	case nm != "" && nm[0] == '<':
 		paths = c.ctx.sysIncludePaths
 		sys = true
 		b = '>'
 	case nm == "":
 		c.err(toks[0], "invalid empty include argument")
 		return
 	default:
 		c.err(toks[0], "invalid include argument %s", nm)
 		return
 	}
 
 	x := strings.IndexByte(nm[1:], b)
 	if x < 0 {
 		c.err(toks[0], "invalid include argument %s", nm)
 		return
 	}
 
 	nm = filepath.FromSlash(nm[1 : x+1])
 	var path string
 	switch {
 	case filepath.IsAbs(nm):
 		path = nm
 	default:
 		dir := filepath.Dir(c.file.Name())
 		if n.includeNext {
 			nmDir, _ := filepath.Split(nm)
 			for i, v := range paths {
 				if w, err := filepath.Abs(v); err == nil {
 					v = w
 				}
 				v = filepath.Join(v, nmDir)
 				if v == dir {
 					paths = paths[i+1:]
 					break
 				}
 			}
 		}
 		for _, v := range paths {
 			if v == "@" {
 				v = dir
 			}
 
 			p := filepath.Join(v, nm)
 			fi, err := c.ctx.statFile(p, sys)
 			if err != nil || fi.IsDir() {
 				continue
 			}
 
 			path = p
 			break
 		}
 	}
 
 	if path == "" {
 		wd, _ := os.Getwd()
 		c.err(toks[0], "include file not found: %s (wd %s)\nsearch paths:\n\t%s", nm, wd, strings.Join(paths, "\n\t"))
 		return
 	}
 
 	if h := c.ctx.cfg.IncludeFileHandler; h != nil {
 		var position gotoken.Position
 		if p := toks[0].Pos(); p.IsValid() {
 			position = gotoken.Position(c.file.PositionFor(p, true))
 		}
 		apath, err := filepath.Abs(path)
 		if err != nil {
 			c.err(toks[0], "%s: cannot compute absolute path: %v", path, err)
 		}
 		h(position, apath)
 	}
 	cf, err := cache.getFile(c.ctx, path, sys, false)
 	if err != nil {
 		c.err(toks[0], "%s: %v", path, err)
 		return
 	}
 
 	pf, err := cf.ppFile()
 	if err != nil {
 		c.err(toks[0], "%s: %v", path, err)
 		return
 	}
 
 	saveFile := c.file
 	saveFileMacro := c.fileMacro.repl[0].value
 
 	c.file = pf.file
 	c.fileMacro.repl[0].value = dict.sid(fmt.Sprintf("%q", c.file.Name()))
 
 	defer func() {
 		c.file = saveFile
 		c.fileMacro.repl[0].value = saveFileMacro
 	}()
 
 	pf.translationPhase4(c)
 }
 
 func (c *cpp) send(toks []token3) {
 	c.in <- toks
 	<-c.rq
 }
 
 func (c *cpp) identicalReplacementLists(a, b []token3) bool {
 	for len(a) != 0 && a[0].char == ' ' {
 		a = a[1:]
 	}
 	for len(b) != 0 && b[0].char == ' ' {
 		b = b[1:]
 	}
 	for len(a) != 0 && a[len(a)-1].char == ' ' {
 		a = a[:len(a)-1]
 	}
 	for len(b) != 0 && b[len(b)-1].char == ' ' {
 		b = b[:len(b)-1]
 	}
 	if len(a) != len(b) {
 		return false
 	}
 
 	for i, v := range a {
 		w := b[i]
 		if v.char != w.char || v.value != w.value {
 			return false
 		}
 	}
 	return true
 }
 
 func stringConst(ctx *context, t cppToken) string {
 	s := t.String()
 	switch t.char {
 	case LONGSTRINGLITERAL:
 		s = s[1:] // Remove leading 'L'.
 		fallthrough
 	case STRINGLITERAL:
 		var buf bytes.Buffer
 		for i := 1; i < len(s)-1; {
 			switch c := s[i]; c {
 			case '\\':
 				r, n := decodeEscapeSequence(ctx, t, s[i:])
 				switch {
 				case r < 0:
 					buf.WriteByte(byte(-r))
 				default:
 					buf.WriteRune(r)
 				}
 				i += n
 			default:
 				buf.WriteByte(c)
 				i++
 			}
 		}
 		return buf.String()
 	}
 	panic(internalError())
 }
 
 // -------------------------------------------------------- Translation phase 4
 
 // [0], 5.1.1.2, 4
 //
 // Preprocessing directives are executed, macro invocations are expanded, and
 // _Pragma unary operator expressions are executed. If a character sequence
 // that matches the syntax of a universal character name is produced by token
 // concatenation (6.10.3.3), the behavior is undefined. A #include
 // preprocessing directive causes the named header or source file to be
 // processed from phase 1 through phase 4, recursively. All preprocessing
 // directives are then deleted.
 func (c *cpp) translationPhase4(in []source) chan *[]token4 {
 	c.rq = make(chan struct{})       // Must be unbufferred
 	c.in = make(chan []token3)       // Must be unbufferred
 	c.out = make(chan *[]token4, 10) //DONE benchmark tuned
 
 	go func() {
 		defer close(c.out)
 
 		c.expand(c, c, false)
 	}()
 
 	go func() {
 		defer close(c.in)
 
 		for _, v := range in {
 			pf, err := v.ppFile()
 			if err != nil {
 				c.err(nil, "%s", err)
 				break
 			}
 
 			c.file = pf.file
 			c.fileMacro.repl[0].value = dict.sid(fmt.Sprintf("%q", c.file.Name()))
 			pf.translationPhase4(c)
 		}
 	}()
 
 	return c.out
 }
 
 type ppErrorDirective struct {
 	toks []token3
 	msg  []token3
 }
 
 func (n *ppErrorDirective) getToks() []token3 { return n.toks }
 
 func (n *ppErrorDirective) translationPhase4(c *cpp) {
 	var b strings.Builder
 	for _, v := range n.msg {
 		b.WriteString(v.String())
 	}
 	c.err(n.toks[0], "%s", strings.TrimSpace(b.String()))
 }
 
 type ppPragmaDirective struct {
 	toks []token3
 	args []token3
 }
 
 func (n *ppPragmaDirective) getToks() []token3 { return n.toks }
 
 func (n *ppPragmaDirective) translationPhase4(c *cpp) { parsePragma(c, n.args) }
 
 func parsePragma(c *cpp, args0 []token3) {
 	if len(args0) == 1 { // \n
 		return
 	}
 
 	if t := args0[0]; t.char == IDENTIFIER && t.value == idSTDC {
 		p := t
 		p.char = PRAGMASTDC
 		p.value = idPragmaSTDC
 		send := []token3{p, {char: ' ', value: idSpace, src: idSpace, pos: t.pos}}
 		args := ltrim3(args0[1:])
 		if len(args) == 0 {
 			c.err(args[0], "expected argument of STDC")
 			return
 		}
 
 		if t = args[0]; t.char != IDENTIFIER {
 			c.err(t, "expected identifier")
 			return
 		}
 
 		switch t.value {
 		case idFPContract, idFenvAccess, idCxLimitedRange:
 			// ok
 		default:
 			c.err(t, "expected FP_CONTRACT or FENV_ACCESS or CX_LIMITED_RANGE")
 			return
 		}
 
 		args = ltrim3(args[1:])
 		if len(args) == 0 {
 			c.err(args[0], "expected ON or OFF or DEFAULT")
 			return
 		}
 
 		if t = args[0]; t.char != IDENTIFIER {
 			c.err(t, "expected identifier")
 			return
 		}
 
 		switch t.value {
 		case idOn, idOff, idDefault:
 			c.writes(c.cppToks(append(send, args0...)))
 		default:
 			c.err(t, "expected ON or OFF or DEFAULT")
 			return
 		}
 	}
 
 	if c.ctx.cfg.PragmaHandler == nil {
 		return
 	}
 
 	var toks []cppToken
 	for _, v := range args0[:len(args0)-1] {
 		toks = append(toks, cppToken{token4: token4{file: c.file, token3: v}})
 	}
 	if len(toks) == 0 {
 		return
 	}
 
 	var toks2 []Token
 	var sep StringID
 	for _, tok := range toks {
 		switch tok.char {
 		case ' ', '\n':
 			if c.ctx.cfg.PreserveOnlyLastNonBlankSeparator {
 				if strings.TrimSpace(tok.value.String()) != "" {
 					sep = tok.value
 				}
 				break
 			}
 
 			switch {
 			case sep != 0:
 				sep = dict.sid(sep.String() + tok.String()) //TODO quadratic
 			default:
 				sep = tok.value
 			}
 		default:
 			var t Token
 			t.Rune = tok.char
 			t.Sep = sep
 			t.Value = tok.value
 			t.file = tok.file
 			t.pos = tok.pos
 			toks2 = append(toks2, t)
 			sep = 0
 		}
 	}
 	if len(toks2) == 0 {
 		return
 	}
 
 	// dbg("%v: %q", c.file.PositionFor(args0[0].Pos(), true), tokStr(toks2, "|"))
 	c.ctx.cfg.PragmaHandler(&pragma{tok: toks[0], c: c}, toks2)
 }
 
 type ppNonDirective struct {
 	toks []token3
 }
 
 func (n *ppNonDirective) getToks() []token3 { return n.toks }
 
 func (n *ppNonDirective) translationPhase4(c *cpp) {
 	// nop
 }
 
 type ppTextLine struct {
 	toks []token3
 }
 
 func (n *ppTextLine) getToks() []token3 { return n.toks }
 
 func (n *ppTextLine) translationPhase4(c *cpp) { c.send(n.toks) }
 
 type ppLineDirective struct {
 	toks    []token3
 	args    []token3
 	nextPos int
 }
 
 func (n *ppLineDirective) getToks() []token3 { return n.toks }
 
 func (n *ppLineDirective) translationPhase4(c *cpp) {
 	toks := expandArgs(c, n.args)
 	if len(toks) == 0 {
 		return
 	}
 
 	switch t := toks[0]; t.char {
 	case PPNUMBER:
 		ln, err := strconv.ParseInt(t.String(), 10, 31)
 		if err != nil || ln < 1 {
 			c.err(t, "expected positive integer less or equal 2147483647")
 			return
 		}
 
 		for len(toks) != 0 && toks[0].char == ' ' {
 			toks = toks[1:]
 		}
 		if len(toks) == 1 {
 			c.file.AddLineInfo(int(n.nextPos)-1, c.file.Name(), int(ln))
 			return
 		}
 
 		toks = toks[1:]
 		for len(toks) != 0 && toks[0].char == ' ' {
 			toks = toks[1:]
 		}
 		if len(toks) == 0 {
 			c.file.AddLineInfo(int(n.nextPos)-1, c.file.Name(), int(ln))
 			return
 		}
 
 		switch t := toks[0]; t.char {
 		case STRINGLITERAL:
 			s := t.String()
 			s = s[1 : len(s)-1]
 			c.file.AddLineInfo(int(n.nextPos)-1, s, int(ln))
 			c.fileMacro.repl[0].value = t.value
 			for len(toks) != 0 && toks[0].char == ' ' {
 				toks = toks[1:]
 			}
 			if len(toks) != 0 && c.ctx.cfg.RejectLineExtraTokens {
 				c.err(toks[0], "expected new-line")
 			}
 		default:
 			c.err(t, "expected string literal")
 			return
 		}
 	default:
 		c.err(toks[0], "expected integer literal")
 		return
 	}
 }
 
 func expandArgs(c *cpp, args []token3) []cppToken {
 	var w cppWriter
 	var toks []cppToken
 	for _, v := range args {
 		toks = append(toks, cppToken{token4: token4{file: c.file, token3: v}})
 	}
 	c.expand(&cppReader{buf: toks}, &w, true)
 	return w.toks
 }
 
 type ppUndefDirective struct {
 	name token3
 	toks []token3
 }
 
 func (n *ppUndefDirective) getToks() []token3 { return n.toks }
 
 func (n *ppUndefDirective) translationPhase4(c *cpp) {
 	nm := n.name.value
 	if _, ok := protectedMacros[nm]; ok || nm == idDefined {
 		c.err(n.name, "cannot undefine a protected name")
 		return
 	}
 
 	// dbg("#undef %s", nm)
 	delete(c.macros, nm)
 }
 
 type ppIfdefDirective struct {
 	name StringID
 	toks []token3
 }
 
 func (n *ppIfdefDirective) evalInclusionCondition(c *cpp) bool { _, ok := c.macros[n.name]; return ok }
 
 func (n *ppIfdefDirective) getToks() []token3 { return n.toks }
 
 type ppIfndefDirective struct {
 	name StringID
 	toks []token3
 }
 
 func (n *ppIfndefDirective) evalInclusionCondition(c *cpp) bool {
 	_, ok := c.macros[n.name]
 	return !ok
 }
 
 func (n *ppIfndefDirective) getToks() []token3 { return n.toks }
 
 type ppIfDirective struct {
 	toks []token3
 	expr []token3
 }
 
 func (n *ppIfDirective) getToks() []token3 { return n.toks }
 
 func (n *ppIfDirective) evalInclusionCondition(c *cpp) bool {
 	return c.evalInclusionCondition(n.expr)
 }
 
 type ppDefineObjectMacroDirective struct {
 	name            token3
 	toks            []token3
 	replacementList []token3
 }
 
 func (n *ppDefineObjectMacroDirective) getToks() []token3 { return n.toks }
 
 func (n *ppDefineObjectMacroDirective) translationPhase4(c *cpp) {
 	nm := n.name.value
 	m := c.macros[nm]
 	if m != nil {
 		if _, ok := protectedMacros[nm]; ok || nm == idDefined {
 			c.err(n.name, "cannot define protected name")
 			return
 		}
 
 		if m.isFnLike {
 			c.err(n.name, "redefinition of a function-like macro with an object-like one")
 		}
 
 		if !c.identicalReplacementLists(n.replacementList, m.repl) && c.ctx.cfg.RejectIncompatibleMacroRedef {
 			c.err(n.name, "redefinition with different replacement list")
 			return
 		}
 	}
 
 	// find first non-blank token to claim as our location
 	var pos int32
 	for _, t := range n.toks {
 		if t.char != ' ' {
 			pos = t.pos
 			break
 		}
 	}
 
 	// dbg("#define %s %s // %v", n.name, tokStr(n.replacementList, " "), c.file.PositionFor(n.name.Pos(), true))
 	c.macros[nm] = &Macro{pos: pos, name: token4{token3: n.name, file: c.file}, repl: n.replacementList}
 	if nm != idGNUC {
 		return
 	}
 
 	c.ctx.keywords = gccKeywords
 }
 
 type ppDefineFunctionMacroDirective struct {
 	identifierList  []token3
 	toks            []token3
 	replacementList []token3
 
 	name token3
 
 	namedVariadic bool // foo..., note no comma before ellipsis.
 	variadic      bool
 }
 
 func (n *ppDefineFunctionMacroDirective) getToks() []token3 { return n.toks }
 
 func (n *ppDefineFunctionMacroDirective) translationPhase4(c *cpp) {
 	nm := n.name.value
 	m := c.macros[nm]
 	if m != nil {
 		if _, ok := protectedMacros[nm]; ok || nm == idDefined {
 			c.err(n.name, "cannot define protected name")
 			return
 		}
 
 		if !m.isFnLike && c.ctx.cfg.RejectIncompatibleMacroRedef {
 			c.err(n.name, "redefinition of an object-like macro with a function-like one")
 			return
 		}
 
 		ok := len(m.fp) == len(n.identifierList)
 		if ok {
 			for i, v := range m.fp {
 				if v != n.identifierList[i].value {
 					ok = false
 					break
 				}
 			}
 		}
 		if !ok && (len(n.replacementList) != 0 || len(m.repl) != 0) && c.ctx.cfg.RejectIncompatibleMacroRedef {
 			c.err(n.name, "redefinition with different formal parameters")
 			return
 		}
 
 		if !c.identicalReplacementLists(n.replacementList, m.repl) && c.ctx.cfg.RejectIncompatibleMacroRedef {
 			c.err(n.name, "redefinition with different replacement list")
 			return
 		}
 
 		if m.variadic != n.variadic && c.ctx.cfg.RejectIncompatibleMacroRedef {
 			c.err(n.name, "redefinition differs in being variadic")
 			return
 		}
 	}
 	nms := map[StringID]struct{}{}
 	for _, v := range n.identifierList {
 		if _, ok := nms[v.value]; ok {
 			c.err(v, "duplicate identifier %s", v.value)
 		}
 	}
 	var fp []StringID
 	for _, v := range n.identifierList {
 		fp = append(fp, v.value)
 	}
 	// dbg("#define %s %s // %v", n.name, tokStr(n.replacementList, " "), c.file.PositionFor(n.name.Pos(), true))
 	c.macros[nm] = &Macro{fp: fp, isFnLike: true, name: token4{token3: n.name, file: c.file}, repl: n.replacementList, variadic: n.variadic, namedVariadic: n.namedVariadic}
 }
 
 // [0], 6.10.1
 //
 //  elif-group:
 //  		# elif constant-expression new-line group_opt
 type ppElifGroup struct {
 	elif   *ppElifDirective
 	groups []ppGroup
 }
 
 func (n *ppElifGroup) evalInclusionCondition(c *cpp) bool {
 	if !c.evalInclusionCondition(n.elif.expr) {
 		return false
 	}
 
 	for _, v := range n.groups {
 		v.translationPhase4(c)
 	}
 	return true
 }
 
 // [0], 6.10.1
 //
 //  else-group:
 //  		# else new-line group_opt
 type ppElseGroup struct {
 	elseLine *ppElseDirective
 	groups   []ppGroup
 }
 
 func (n *ppElseGroup) translationPhase4(c *cpp) {
 	if n == nil {
 		return
 	}
 
 	for _, v := range n.groups {
 		v.translationPhase4(c)
 	}
 }
 
 // [0], 6.10.1
 //
 //  PreprocessingFile:
 //  		GroupOpt
 type ppFile struct {
 	file   *tokenFile
 	groups []ppGroup
 }
 
 func (n *ppFile) translationPhase4(c *cpp) {
 	c.ctx.tuSourcesAdd(1)
 	if f := n.file; f != nil {
 		c.ctx.tuSizeAdd(int64(f.Size()))
 	}
 	for _, v := range n.groups {
 		v.translationPhase4(c)
 	}
 }
 
 // [0], 6.10.1
 //
 //  group-part:
 //  		if-section
 //  		control-line
 //  		text-line
 //  		# non-directive
 type ppGroup interface {
 	translationPhase4(*cpp)
 }
 
 // [0], 6.10.1
 //
 //  if-group:
 //  		# if constant-expression new-line group opt
 //  		# ifdef identifier new-line group opt
 //  		# ifndef identifier new-line group opt
 type ppIfGroup struct {
 	directive ppIfGroupDirective
 	groups    []ppGroup
 }
 
 func (n *ppIfGroup) evalInclusionCondition(c *cpp) bool {
 	if !n.directive.evalInclusionCondition(c) {
 		return false
 	}
 
 	for _, v := range n.groups {
 		v.translationPhase4(c)
 	}
 	return true
 }
 
 // [0], 6.10.1
 //
 // if-section:
 // 		if-group elif-groups_opt else-group_opt endif-line
 type ppIfSection struct {
 	ifGroup    *ppIfGroup
 	elifGroups []*ppElifGroup
 	elseGroup  *ppElseGroup
 	endifLine  *ppEndifDirective
 }
 
 func (n *ppIfSection) translationPhase4(c *cpp) {
 	if !n.ifGroup.evalInclusionCondition(c) {
 		for _, v := range n.elifGroups {
 			if v.evalInclusionCondition(c) {
 				return
 			}
 		}
 
 		n.elseGroup.translationPhase4(c)
 	}
 }