Add dependencies/vendor (whatsapp)

1 files changed, 3101 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/cpp.go b/vendor/modernc.org/cc/v3/cpp.go
new file mode 100644
index 00000000..db4cee0f
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/cpp.go
@@ -0,0 +1,3101 @@
+// 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)
+	}
+}