Add dependencies/vendor (whatsapp)

1 files changed, 1266 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/scanner.go b/vendor/modernc.org/cc/v3/scanner.go
new file mode 100644
index 00000000..6217d7db
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/scanner.go
@@ -0,0 +1,1266 @@
+// 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 (
+	"bufio"
+	"bytes"
+	"fmt"
+	goscanner "go/scanner"
+	"io"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode/utf8"
+
+	"modernc.org/mathutil"
+	"modernc.org/token"
+)
+
+const (
+	clsEOF = iota + 0x80
+	clsOther
+)
+
+const maxASCII = 0x7f
+
+var (
+	bom = []byte{0xEF, 0xBB, 0xBF}
+
+	idDefine      = dict.sid("define")
+	idElif        = dict.sid("elif")
+	idElse        = dict.sid("else")
+	idEndif       = dict.sid("endif")
+	idError       = dict.sid("error")
+	idIf          = dict.sid("if")
+	idIfdef       = dict.sid("ifdef")
+	idIfndef      = dict.sid("ifndef")
+	idInclude     = dict.sid("include")
+	idIncludeNext = dict.sid("include_next")
+	idLine        = dict.sid("line")
+	idPragma      = dict.sid("pragma")
+	idPragmaOp    = dict.sid("_Pragma")
+	idSpace       = dict.sid(" ")
+	idUndef       = dict.sid("undef")
+
+	trigraphPrefix = []byte("??")
+	trigraphs      = []struct{ from, to []byte }{
+		{[]byte("??="), []byte{'#'}},
+		{[]byte("??("), []byte{'['}},
+		{[]byte("??/"), []byte{'\\'}},
+		{[]byte("??)"), []byte{']'}},
+		{[]byte("??'"), []byte{'^'}},
+		{[]byte("??<"), []byte{'{'}},
+		{[]byte("??!"), []byte{'|'}},
+		{[]byte("??>"), []byte{'}'}},
+		{[]byte("??-"), []byte{'~'}},
+	}
+)
+
+type tokenFile struct {
+	*token.File
+	sync.RWMutex
+}
+
+func tokenNewFile(name string, sz int) *tokenFile { return &tokenFile{File: token.NewFile(name, sz)} }
+
+func (f *tokenFile) Position(pos token.Pos) (r token.Position) {
+	f.RLock()
+	r = f.File.Position(pos)
+	f.RUnlock()
+	return r
+}
+
+func (f *tokenFile) PositionFor(pos token.Pos, adjusted bool) (r token.Position) {
+	f.RLock()
+	r = f.File.PositionFor(pos, adjusted)
+	f.RUnlock()
+	return r
+}
+
+func (f *tokenFile) AddLine(off int) {
+	f.Lock()
+	f.File.AddLine(off)
+	f.Unlock()
+}
+
+func (f *tokenFile) AddLineInfo(off int, fn string, line int) {
+	f.Lock()
+	f.File.AddLineInfo(off, fn, line)
+	f.Unlock()
+}
+
+type node interface {
+	Pos() token.Pos
+}
+
+type dictionary struct {
+	mu      sync.RWMutex
+	m       map[string]StringID
+	strings []string
+}
+
+func newDictionary() (r *dictionary) {
+	r = &dictionary{m: map[string]StringID{}}
+	b := make([]byte, 1)
+	for i := 0; i < 128; i++ {
+		var s string
+		if i != 0 {
+			b[0] = byte(i)
+			s = string(b)
+		}
+		r.m[s] = StringID(i)
+		r.strings = append(r.strings, s)
+		dictStrings[i] = s
+	}
+	return r
+}
+
+func (d *dictionary) id(key []byte) StringID {
+	switch len(key) {
+	case 0:
+		return 0
+	case 1:
+		if c := key[0]; c != 0 && c < 128 {
+			return StringID(c)
+		}
+	}
+
+	d.mu.Lock()
+	if n, ok := d.m[string(key)]; ok {
+		d.mu.Unlock()
+		return n
+	}
+
+	n := StringID(len(d.strings))
+	s := string(key)
+	if int(n) < 256 {
+		dictStrings[n] = s
+	}
+	d.strings = append(d.strings, s)
+	d.m[s] = n
+	d.mu.Unlock()
+	return n
+}
+
+func (d *dictionary) sid(key string) StringID {
+	switch len(key) {
+	case 0:
+		return 0
+	case 1:
+		if c := key[0]; c != 0 && c < 128 {
+			return StringID(c)
+		}
+	}
+
+	d.mu.Lock()
+	if n, ok := d.m[key]; ok {
+		d.mu.Unlock()
+		return n
+	}
+
+	n := StringID(len(d.strings))
+	if int(n) < 256 {
+		dictStrings[n] = key
+	}
+	d.strings = append(d.strings, key)
+	d.m[key] = n
+	d.mu.Unlock()
+	return n
+}
+
+type char struct {
+	pos int32
+	c   byte
+}
+
+// token3 is produced by translation phase 3.
+type token3 struct {
+	char  rune
+	pos   int32
+	value StringID
+	src   StringID
+	macro StringID
+}
+
+func (t token3) Pos() token.Pos { return token.Pos(t.pos) }
+func (t token3) String() string { return t.value.String() }
+
+type scanner struct {
+	bomFix        int
+	bytesBuf      []byte
+	charBuf       []char
+	ctx           *context
+	file          *tokenFile
+	fileOffset    int
+	firstPos      token.Pos
+	lineBuf       []byte
+	lookaheadChar char
+	lookaheadLine ppLine
+	mark          int
+	pos           token.Pos
+	r             *bufio.Reader
+	srcBuf        []byte
+	tokenBuf      []token3
+	ungetBuf      []char
+
+	tok token3
+
+	closed             bool
+	preserveWhiteSpace bool
+}
+
+func newScanner0(ctx *context, r io.Reader, file *tokenFile, bufSize int) *scanner {
+	s := &scanner{
+		ctx:  ctx,
+		file: file,
+		r:    bufio.NewReaderSize(r, bufSize),
+	}
+	if r != nil {
+		s.init()
+	}
+	return s
+}
+
+func newScanner(ctx *context, r io.Reader, file *tokenFile) *scanner {
+	bufSize := 1 << 17 // emulate gcc
+	if n := ctx.cfg.MaxSourceLine; n > 4096 {
+		bufSize = n
+	}
+	return newScanner0(ctx, r, file, bufSize)
+}
+
+func (s *scanner) abort() (r byte, b bool) {
+	if s.mark >= 0 {
+		if len(s.charBuf) > s.mark {
+			s.unget(s.lookaheadChar)
+			for i := len(s.charBuf) - 1; i >= s.mark; i-- {
+				s.unget(s.charBuf[i])
+			}
+		}
+		s.charBuf = s.charBuf[:s.mark]
+		return 0, false
+	}
+
+	switch n := len(s.charBuf); n {
+	case 0: // [] z
+		c := s.lookaheadChar
+		s.next()
+		return s.class(c.c), true
+	case 1: // [a] z
+		return s.class(s.charBuf[0].c), true
+	default: // [a, b, ...], z
+		c := s.charBuf[0]        // a
+		s.unget(s.lookaheadChar) // z
+		for i := n - 1; i > 1; i-- {
+			s.unget(s.charBuf[i]) // ...
+		}
+		s.lookaheadChar = s.charBuf[1] // b
+		s.charBuf = s.charBuf[:1]
+		return s.class(c.c), true
+	}
+}
+
+func (s *scanner) class(b byte) byte {
+	switch {
+	case b == 0:
+		return clsEOF
+	case b > maxASCII:
+		return clsOther
+	default:
+		return b
+	}
+}
+
+func (s *scanner) err(n node, msg string, args ...interface{}) { s.errPos(n.Pos(), msg, args...) }
+
+func (s *scanner) errLine(x interface{}, msg string, args ...interface{}) {
+	var toks []token3
+	switch x := x.(type) {
+	case nil:
+		toks = []token3{{}}
+	case ppLine:
+		toks = x.getToks()
+	default:
+		panic(internalError())
+	}
+	var b strings.Builder
+	for _, v := range toks {
+		switch v.char {
+		case '\n':
+			// nop
+		case ' ':
+			b.WriteByte(' ')
+		default:
+			b.WriteString(v.String())
+		}
+	}
+	s.err(toks[0], "%s"+msg, append([]interface{}{b.String()}, args...)...)
+}
+
+func (s *scanner) errPos(pos token.Pos, msg string, args ...interface{}) {
+	if s.ctx.err(s.file.Position(pos), msg, args...) {
+		s.r.Reset(nil)
+		s.closed = true
+	}
+}
+
+func (s *scanner) init() *scanner {
+	if s.r == nil {
+		return s
+	}
+
+	b, err := s.r.Peek(3)
+	if err == nil && bytes.Equal(b, bom) {
+		s.bomFix, _ = s.r.Discard(3)
+	}
+	s.tokenBuf = nil
+	return s
+}
+
+func (s *scanner) initScan() (r byte) {
+	if s.lookaheadChar.pos == 0 {
+		s.next()
+	}
+	s.firstPos = token.Pos(s.lookaheadChar.pos)
+	s.mark = -1
+	if len(s.charBuf) > 1<<18 { //DONE benchmark tuned
+		s.bytesBuf = nil
+		s.charBuf = nil
+		s.srcBuf = nil
+	} else {
+		s.bytesBuf = s.bytesBuf[:0]
+		s.charBuf = s.charBuf[:0]
+		s.srcBuf = s.bytesBuf[:0]
+	}
+	return s.class(s.lookaheadChar.c)
+}
+
+func (s *scanner) lex() {
+	s.tok.char = s.scan()
+	s.tok.pos = int32(s.firstPos)
+	for _, v := range s.charBuf {
+		s.srcBuf = append(s.srcBuf, v.c)
+	}
+	s.tok.src = dict.id(s.srcBuf)
+	switch {
+	case s.tok.char == ' ' && !s.preserveWhiteSpace && !s.ctx.cfg.PreserveWhiteSpace:
+		s.tok.value = idSpace
+	case s.tok.char == IDENTIFIER:
+		for i := 0; i < len(s.charBuf); {
+			c := s.charBuf[i].c
+			if c != '\\' {
+				s.bytesBuf = append(s.bytesBuf, c)
+				i++
+				continue
+			}
+
+			i++ // Skip '\\'
+			var n int
+			switch s.charBuf[i].c {
+			case 'u':
+				n = 4
+			case 'U':
+				n = 8
+			default:
+				panic(internalError())
+			}
+			i++ // Skip 'u' or 'U'
+			l := len(s.bytesBuf)
+			for i0 := i; i < i0+n; i++ {
+				s.bytesBuf = append(s.bytesBuf, s.charBuf[i].c)
+			}
+			r, err := strconv.ParseUint(string(s.bytesBuf[l:l+n]), 16, 32)
+			if err != nil {
+				panic(internalError())
+			}
+
+			n2 := utf8.EncodeRune(s.bytesBuf[l:], rune(r))
+			s.bytesBuf = s.bytesBuf[:l+n2]
+		}
+		s.tok.value = dict.id(s.bytesBuf)
+	default:
+		s.tok.value = s.tok.src
+	}
+	switch s.tok.char {
+	case clsEOF:
+		s.tok.char = -1
+		s.tok.pos = int32(s.file.Pos(s.file.Size()))
+	}
+	// dbg("lex %q %q", tokName(s.tok.char), s.tok.value)
+}
+
+func (s *scanner) next() (r byte) {
+	if s.lookaheadChar.pos > 0 {
+		s.charBuf = append(s.charBuf, s.lookaheadChar)
+	}
+	if n := len(s.ungetBuf); n != 0 {
+		s.lookaheadChar = s.ungetBuf[n-1]
+		s.ungetBuf = s.ungetBuf[:n-1]
+		return s.class(s.lookaheadChar.c)
+	}
+
+	if len(s.lineBuf) == 0 {
+	more:
+		if s.closed || s.fileOffset == s.file.Size() {
+			s.lookaheadChar.c = 0
+			s.lookaheadChar.pos = 0
+			return clsEOF
+		}
+
+		b, err := s.r.ReadSlice('\n')
+		if err != nil {
+			if err != io.EOF {
+				s.errPos(s.pos, "error while reading %s: %s", s.file.Name(), err)
+			}
+			if len(b) == 0 {
+				return clsEOF
+			}
+		}
+
+		s.file.AddLine(s.fileOffset)
+		s.fileOffset += s.bomFix
+		s.bomFix = 0
+		s.pos = token.Pos(s.fileOffset)
+		s.fileOffset += len(b)
+
+		// [0], 5.1.1.2, 1.1
+		//
+		// Physical source file multibyte characters are mapped, in an
+		// implementation- defined manner, to the source character set
+		// (introducing new-line characters for end-of-line indicators)
+		// if necessary. Trigraph sequences are replaced by
+		// corresponding single-character internal representations.
+		if !s.ctx.cfg.DisableTrigraphs && bytes.Contains(b, trigraphPrefix) {
+			for _, v := range trigraphs {
+				b = bytes.Replace(b, v.from, v.to, -1)
+			}
+		}
+
+		// [0], 5.1.1.2, 2
+		//
+		// Each instance of a backslash character (\) immediately
+		// followed by a new-line character is deleted, splicing
+		// physical source lines to form logical source lines.  Only
+		// the last backslash on any physical source line shall be
+		// eligible for being part of such a splice. A source file that
+		// is not empty shall end in a new-line character, which shall
+		// not be immediately preceded by a backslash character before
+		// any such splicing takes place.
+		s.lineBuf = b
+		n := len(b)
+		switch {
+		case b[n-1] != '\n':
+			if s.ctx.cfg.RejectMissingFinalNewline {
+				s.errPos(s.pos+token.Pos(n), "non empty source file shall end in a new-line character")
+			}
+			b = append(b[:n:n], '\n') // bufio.Reader owns the bytes
+		case n > 1 && b[n-2] == '\\':
+			if n == 2 {
+				goto more
+			}
+
+			b = b[:n-2]
+			n = len(b)
+			if s.fileOffset == s.file.Size() {
+				if s.ctx.cfg.RejectFinalBackslash {
+					s.errPos(s.pos+token.Pos(n+1), "source file final new-line character shall not be preceded by a backslash character")
+				}
+				b = append(b[:n:n], '\n') // bufio.Reader owns the bytes
+			}
+		case n > 2 && b[n-3] == '\\' && b[n-2] == '\r':
+			// we've got a windows source that has \r\n line endings.
+			if n == 3 {
+				goto more
+			}
+
+			b = b[:n-3]
+			n = len(b)
+			if s.fileOffset == s.file.Size() {
+				if s.ctx.cfg.RejectFinalBackslash {
+					s.errPos(s.pos+token.Pos(n+1), "source file final new-line character shall not be preceded by a backslash character")
+				}
+				b = append(b[:n:n], '\n') // bufio.Reader owns the bytes
+			}
+		}
+		s.lineBuf = b
+	}
+	s.pos++
+	s.lookaheadChar = char{int32(s.pos), s.lineBuf[0]}
+	s.lineBuf = s.lineBuf[1:]
+	return s.class(s.lookaheadChar.c)
+}
+
+func (s *scanner) unget(c ...char) {
+	s.ungetBuf = append(s.ungetBuf, c...)
+	s.lookaheadChar.pos = 0 // Must invalidate lookahead.
+}
+
+func (s *scanner) unterminatedComment() rune {
+	s.errPos(token.Pos(s.file.Size()), "unterminated comment")
+	n := len(s.charBuf)
+	s.unget(s.charBuf[n-1]) // \n
+	s.charBuf = s.charBuf[:n-1]
+	return ' '
+}
+
+// -------------------------------------------------------- Translation phase 3
+
+// [0], 5.1.1.2, 3
+//
+// The source file is decomposed into preprocessing tokens and sequences of
+// white-space characters (including comments). A source file shall not end in
+// a partial preprocessing token or in a partial comment. Each comment is
+// replaced by one space character. New-line characters are retained. Whether
+// each nonempty sequence of white-space characters other than new-line is
+// retained or replaced by one space character is implementation-defined.
+func (s *scanner) translationPhase3() *ppFile {
+	r := &ppFile{file: s.file}
+	if s.file.Size() == 0 {
+		s.r.Reset(nil)
+		return r
+	}
+
+	s.nextLine()
+	r.groups = s.parseGroup()
+	return r
+}
+
+func (s *scanner) parseGroup() (r []ppGroup) {
+	for {
+		switch x := s.lookaheadLine.(type) {
+		case ppGroup:
+			r = append(r, x)
+			s.nextLine()
+		case ppIfGroupDirective:
+			r = append(r, s.parseIfSection())
+		default:
+			return r
+		}
+	}
+}
+
+func (s *scanner) parseIfSection() *ppIfSection {
+	return &ppIfSection{
+		ifGroup:    s.parseIfGroup(),
+		elifGroups: s.parseElifGroup(),
+		elseGroup:  s.parseElseGroup(),
+		endifLine:  s.parseEndifLine(),
+	}
+}
+
+func (s *scanner) parseEndifLine() *ppEndifDirective {
+	switch x := s.lookaheadLine.(type) {
+	case *ppEndifDirective:
+		s.nextLine()
+		return x
+	default:
+		s.errLine(x, fmt.Sprintf(": expected #endif (unexpected %T)", x))
+		s.nextLine()
+		return nil
+	}
+}
+
+func (s *scanner) parseElseGroup() *ppElseGroup {
+	switch x := s.lookaheadLine.(type) {
+	case *ppElseDirective:
+		r := &ppElseGroup{elseLine: x}
+		s.nextLine()
+		r.groups = s.parseGroup()
+		return r
+	default:
+		return nil
+	}
+}
+
+func (s *scanner) parseElifGroup() (r []*ppElifGroup) {
+	for {
+		var g ppElifGroup
+		switch x := s.lookaheadLine.(type) {
+		case *ppElifDirective:
+			g.elif = x
+			s.nextLine()
+			g.groups = s.parseGroup()
+			r = append(r, &g)
+		default:
+			return r
+		}
+	}
+}
+
+func (s *scanner) parseIfGroup() *ppIfGroup {
+	r := &ppIfGroup{}
+	switch x := s.lookaheadLine.(type) {
+	case ppIfGroupDirective:
+		r.directive = x
+	default:
+		s.errLine(x, fmt.Sprintf(": expected if-group (unexpected %T)", x))
+	}
+	s.nextLine()
+	r.groups = s.parseGroup()
+	return r
+}
+
+func (s *scanner) nextLine() {
+	s.tokenBuf = nil
+	s.lookaheadLine = s.scanLine()
+}
+
+func (s *scanner) scanLine() (r ppLine) {
+again:
+	toks := s.scanToNonBlankToken(nil)
+	if len(toks) == 0 {
+		return nil
+	}
+
+	includeNext := false
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '#':
+		toks = s.scanToNonBlankToken(toks)
+		switch tok := toks[len(toks)-1]; tok.char {
+		case '\n':
+			return &ppEmptyDirective{toks: toks}
+		case IDENTIFIER:
+			switch tok.value {
+			case idDefine:
+				return s.parseDefine(toks)
+			case idElif:
+				return s.parseElif(toks)
+			case idElse:
+				return s.parseElse(toks)
+			case idEndif:
+				return s.parseEndif(toks)
+			case idIf:
+				return s.parseIf(toks)
+			case idIfdef:
+				return s.parseIfdef(toks)
+			case idIfndef:
+				return s.parseIfndef(toks)
+			case idIncludeNext:
+				includeNext = true
+				fallthrough
+			case idInclude:
+				// # include pp-tokens new-line
+				//
+				// Prevent aliasing of eg. <foo  bar.h> and <foo bar.h>.
+				save := s.preserveWhiteSpace
+				s.preserveWhiteSpace = true
+				n := len(toks)
+				toks := s.scanLineToEOL(toks)
+				r := &ppIncludeDirective{arg: toks[n : len(toks)-1], toks: toks, includeNext: includeNext}
+				s.preserveWhiteSpace = save
+				return r
+			case idUndef:
+				return s.parseUndef(toks)
+			case idLine:
+				return s.parseLine(toks)
+			case idError:
+				// # error pp-tokens_opt new-line
+				n := len(toks)
+				toks := s.scanLineToEOL(toks)
+				msg := toks[n : len(toks)-1]
+				if len(msg) != 0 && msg[0].char == ' ' {
+					msg = msg[1:]
+				}
+				return &ppErrorDirective{toks: toks, msg: msg}
+			case idPragma:
+				return s.parsePragma(toks)
+			}
+		}
+
+		// # non-directive
+		return &ppNonDirective{toks: s.scanLineToEOL(toks)}
+	case '\n':
+		return &ppTextLine{toks: toks}
+	case IDENTIFIER:
+		if tok.value == idPragmaOp {
+			toks = s.scanToNonBlankToken(toks)
+			switch tok = toks[len(toks)-1]; tok.char {
+			case '(':
+				// ok
+			default:
+				s.err(tok, "expected (")
+				return &ppTextLine{toks: toks}
+			}
+
+			var lit string
+			toks = s.scanToNonBlankToken(toks)
+			switch tok = toks[len(toks)-1]; tok.char {
+			case STRINGLITERAL:
+				lit = tok.String()
+			case LONGSTRINGLITERAL:
+				lit = tok.String()[1:] // [0], 6.9.10, 1
+			default:
+				s.err(tok, "expected string literal")
+				return &ppTextLine{toks: toks}
+			}
+
+			pos := tok.pos
+			toks = s.scanToNonBlankToken(toks)
+			switch tok = toks[len(toks)-1]; tok.char {
+			case ')':
+				// ok
+			default:
+				s.err(tok, "expected )")
+				return &ppTextLine{toks: toks}
+			}
+
+			s.unget(s.lookaheadChar)
+			// [0], 6.9.10, 1
+			lit = lit[1 : len(lit)-1]
+			lit = strings.ReplaceAll(lit, `\"`, `"`)
+			lit = strings.ReplaceAll(lit, `\\`, `\`)
+			lit = "#pragma " + lit + "\n"
+			for i := len(lit) - 1; i >= 0; i-- {
+				s.unget(char{pos, lit[i]})
+			}
+			goto again
+		}
+
+		fallthrough
+	default:
+		return &ppTextLine{toks: s.scanLineToEOL(toks)}
+	}
+}
+
+func (s *scanner) parsePragma(toks []token3) *ppPragmaDirective {
+	toks = s.scanToNonBlankToken(toks)
+	n := len(toks)
+	if toks[n-1].char != '\n' {
+		toks = s.scanLineToEOL(toks)
+	}
+	return &ppPragmaDirective{toks: toks, args: toks[n-1:]}
+}
+
+// # line pp-tokens new-line
+func (s *scanner) parseLine(toks []token3) *ppLineDirective {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		s.err(tok, "unexpected new-line")
+		return &ppLineDirective{toks: toks}
+	default:
+		toks := s.scanLineToEOL(toks)
+		last := toks[len(toks)-1]
+		r := &ppLineDirective{toks: toks, nextPos: int(last.pos) + len(last.src.String())}
+		toks = toks[:len(toks)-1] // sans new-line
+		toks = ltrim3(toks)
+		toks = toks[1:] // Skip '#'
+		toks = ltrim3(toks)
+		toks = toks[1:] // Skip "line"
+		r.args = ltrim3(toks)
+		return r
+	}
+}
+
+func ltrim3(toks []token3) []token3 {
+	for len(toks) != 0 && toks[0].char == ' ' {
+		toks = toks[1:]
+	}
+	return toks
+}
+
+// # undef identifier new-line
+func (s *scanner) parseUndef(toks []token3) *ppUndefDirective {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		s.err(&tok, "expected identifier")
+		return &ppUndefDirective{toks: toks}
+	case IDENTIFIER:
+		name := tok
+		toks = s.scanToNonBlankToken(toks)
+		switch tok := toks[len(toks)-1]; tok.char {
+		case '\n':
+			return &ppUndefDirective{name: name, toks: toks}
+		default:
+			if s.ctx.cfg.RejectUndefExtraTokens {
+				s.err(&tok, "extra tokens after #undef")
+			}
+			return &ppUndefDirective{name: name, toks: s.scanLineToEOL(toks)}
+		}
+	default:
+		s.err(&tok, "expected identifier")
+		return &ppUndefDirective{toks: s.scanLineToEOL(toks)}
+	}
+}
+
+func (s *scanner) scanLineToEOL(toks []token3) []token3 {
+	n := len(s.tokenBuf) - len(toks)
+	for {
+		s.lex()
+		s.tokenBuf = append(s.tokenBuf, s.tok)
+		if s.tok.char == '\n' {
+			return s.tokenBuf[n:]
+		}
+	}
+}
+
+// # ifndef identifier new-line
+func (s *scanner) parseIfndef(toks []token3) *ppIfndefDirective {
+	var name StringID
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case IDENTIFIER:
+		name = tok.value
+		toks = s.scanToNonBlankToken(toks)
+		switch tok := toks[len(toks)-1]; tok.char {
+		case '\n':
+			return &ppIfndefDirective{name: name, toks: toks}
+		default:
+			if s.ctx.cfg.RejectIfndefExtraTokens {
+				s.err(&tok, "extra tokens after #ifndef")
+			}
+			return &ppIfndefDirective{name: name, toks: s.scanLineToEOL(toks)}
+		}
+	case '\n':
+		s.err(tok, "expected identifier")
+		return &ppIfndefDirective{name: name, toks: toks}
+	default:
+		s.err(tok, "expected identifier")
+		return &ppIfndefDirective{name: name, toks: s.scanLineToEOL(toks)}
+	}
+}
+
+// # ifdef identifier new-line
+func (s *scanner) parseIfdef(toks []token3) *ppIfdefDirective {
+	var name StringID
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case IDENTIFIER:
+		name = tok.value
+		toks = s.scanToNonBlankToken(toks)
+		switch tok := toks[len(toks)-1]; tok.char {
+		case '\n':
+			return &ppIfdefDirective{name: name, toks: toks}
+		default:
+			if s.ctx.cfg.RejectIfdefExtraTokens {
+				s.err(&tok, "extra tokens after #ifdef")
+			}
+			return &ppIfdefDirective{name: name, toks: s.scanLineToEOL(toks)}
+		}
+	case '\n':
+		s.err(tok, "expected identifier")
+		return &ppIfdefDirective{name: name, toks: toks}
+	default:
+		s.err(tok, "expected identifier")
+		return &ppIfdefDirective{name: name, toks: s.scanLineToEOL(toks)}
+	}
+}
+
+// # if constant-expression new-line
+func (s *scanner) parseIf(toks []token3) *ppIfDirective {
+	n := len(toks)
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		s.err(tok, "expected expression")
+		return &ppIfDirective{toks: toks}
+	default:
+		toks = s.scanLineToEOL(toks)
+		expr := toks[n:]
+		if expr[0].char == ' ' { // sans leading space
+			expr = expr[1:]
+		}
+		expr = expr[:len(expr)-1] // sans '\n'
+		return &ppIfDirective{toks: toks, expr: expr}
+	}
+}
+
+// # endif new-line
+func (s *scanner) parseEndif(toks []token3) *ppEndifDirective {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		return &ppEndifDirective{toks}
+	default:
+		if s.ctx.cfg.RejectEndifExtraTokens {
+			s.err(&tok, "extra tokens after #else")
+		}
+		return &ppEndifDirective{s.scanLineToEOL(toks)}
+	}
+}
+
+// # else new-line
+func (s *scanner) parseElse(toks []token3) *ppElseDirective {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		return &ppElseDirective{toks}
+	default:
+		if s.ctx.cfg.RejectElseExtraTokens {
+			s.err(&tok, "extra tokens after #else")
+		}
+		return &ppElseDirective{s.scanLineToEOL(toks)}
+	}
+}
+
+// # elif constant-expression new-line
+func (s *scanner) parseElif(toks []token3) *ppElifDirective {
+	n := len(toks)
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		s.err(tok, "expected expression")
+		return &ppElifDirective{toks, nil}
+	default:
+		toks = s.scanLineToEOL(toks)
+		expr := toks[n:]
+		if expr[0].char == ' ' { // sans leading space
+			expr = expr[1:]
+		}
+		expr = expr[:len(expr)-1] // sans '\n'
+		return &ppElifDirective{toks, expr}
+	}
+}
+
+func (s *scanner) parseDefine(toks []token3) ppLine {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case IDENTIFIER:
+		name := tok
+		n := len(toks)
+		toks = s.scanToNonBlankToken(toks)
+		switch tok := toks[len(toks)-1]; tok.char {
+		case '\n':
+			return &ppDefineObjectMacroDirective{name: name, toks: toks}
+		case '(':
+			if toks[n].char == ' ' {
+				return s.parseDefineObjectMacro(n, name, toks)
+			}
+
+			return s.parseDefineFunctionMacro(name, toks)
+		default:
+			return s.parseDefineObjectMacro(n, name, toks)
+		}
+	case '\n':
+		s.err(tok, "expected identifier")
+		return &ppDefineObjectMacroDirective{toks: toks}
+	default:
+		s.err(tok, "expected identifier")
+		return &ppDefineObjectMacroDirective{toks: s.scanLineToEOL(toks)}
+	}
+}
+
+// # define identifier lparen identifier-list_opt ) replacement-list new-line
+// # define identifier lparen ... ) replacement-list new-line
+// # define identifier lparen identifier-list , ... ) replacement-list new-line
+func (s *scanner) parseDefineFunctionMacro(name token3, toks []token3) *ppDefineFunctionMacroDirective {
+	// Parse parameters after "#define name(".
+	var list []token3
+	variadic := false
+	namedVariadic := false
+again:
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case IDENTIFIER:
+	more:
+		list = append(list, tok)
+		toks = s.scanToNonBlankToken(toks)
+		switch tok = toks[len(toks)-1]; tok.char {
+		case ',':
+			toks = s.scanToNonBlankToken(toks)
+			switch tok = toks[len(toks)-1]; tok.char {
+			case IDENTIFIER:
+				goto more
+			case DDD:
+				if toks, variadic = s.parseDDD(toks); !variadic {
+					goto again
+				}
+			case ')':
+				s.err(tok, "expected parameter name")
+			default:
+				s.err(tok, "unexpected %q", &tok)
+			}
+		case DDD:
+			namedVariadic = true
+			if s.ctx.cfg.RejectInvalidVariadicMacros {
+				s.err(tok, "expected comma")
+			}
+			if toks, variadic = s.parseDDD(toks); !variadic {
+				goto again
+			}
+		case ')':
+			// ok
+		case '\n':
+			s.err(tok, "unexpected new-line")
+			return &ppDefineFunctionMacroDirective{toks: toks}
+		case IDENTIFIER:
+			s.err(tok, "expected comma")
+			goto more
+		default:
+			s.err(tok, "unexpected %q", &tok)
+		}
+	case DDD:
+		if toks, variadic = s.parseDDD(toks); !variadic {
+			goto again
+		}
+	case ',':
+		s.err(tok, "expected parameter name")
+		goto again
+	case ')':
+		// ok
+	default:
+		s.err(tok, "expected parameter name")
+		goto again
+	}
+	// Parse replacement list.
+	n := len(toks)
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case '\n':
+		if s.ctx.cfg.RejectFunctionMacroEmptyReplacementList {
+			s.err(tok, "expected replacement list")
+		}
+		return &ppDefineFunctionMacroDirective{name: name, identifierList: list, toks: toks, variadic: variadic, namedVariadic: namedVariadic}
+	default:
+		toks = s.scanLineToEOL(toks)
+		repl := toks[n:]          // sans #define identifier
+		repl = repl[:len(repl)-1] // sans '\n'
+		// 6.10.3, 7
+		//
+		// Any white-space characters preceding or following the
+		// replacement list of preprocessing tokens are not considered
+		// part of the replacement list for either form of macro.
+		repl = trim3(repl)
+		repl = normalizeHashes(repl)
+		return &ppDefineFunctionMacroDirective{name: name, identifierList: list, toks: toks, replacementList: repl, variadic: variadic, namedVariadic: namedVariadic}
+	}
+}
+
+func isWhite(char rune) bool {
+	switch char {
+	case ' ', '\t', '\n', '\v', '\f':
+		return true
+	}
+	return false
+}
+
+func trim3(toks []token3) []token3 {
+	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 normalizeHashes(toks []token3) []token3 {
+	w := 0
+	var last rune
+	for _, v := range toks {
+		switch {
+		case v.char == PPPASTE:
+			if isWhite(last) {
+				w--
+			}
+		case isWhite(v.char):
+			if last == '#' || last == PPPASTE {
+				continue
+			}
+		}
+		last = v.char
+		toks[w] = v
+		w++
+	}
+	return toks[:w]
+}
+
+func (s *scanner) parseDDD(toks []token3) ([]token3, bool) {
+	toks = s.scanToNonBlankToken(toks)
+	switch tok := toks[len(toks)-1]; tok.char {
+	case ')':
+		return toks, true
+	default:
+		s.err(tok, "expected right parenthesis")
+		return toks, false
+	}
+}
+
+// # define identifier replacement-list new-line
+func (s *scanner) parseDefineObjectMacro(n int, name token3, toks []token3) *ppDefineObjectMacroDirective {
+	toks = s.scanLineToEOL(toks)
+	repl := toks[n:]          // sans #define identifier
+	repl = repl[:len(repl)-1] // sans '\n'
+	// 6.10.3, 7
+	//
+	// Any white-space characters preceding or following the replacement
+	// list of preprocessing tokens are not considered part of the
+	// replacement list for either form of macro.
+	repl = trim3(repl)
+	repl = normalizeHashes(repl)
+	return &ppDefineObjectMacroDirective{name: name, toks: toks, replacementList: repl}
+}
+
+// Return {}, {x} or {' ', x}
+func (s *scanner) scanToNonBlankToken(toks []token3) []token3 {
+	n := len(s.tokenBuf) - len(toks)
+	for {
+		s.lex()
+		if s.tok.char < 0 {
+			return s.tokenBuf[n:]
+		}
+
+		s.tokenBuf = append(s.tokenBuf, s.tok)
+		if s.tok.char != ' ' {
+			return s.tokenBuf[n:]
+		}
+	}
+}
+
+// ---------------------------------------------------------------------- Cache
+
+// Translation phase4 source.
+type source interface {
+	ppFile() (*ppFile, error)
+}
+
+type cachedPPFile struct {
+	err     error
+	errs    goscanner.ErrorList
+	modTime int64 // time.Time.UnixNano()
+	pf      *ppFile
+	readyCh chan struct{}
+	size    int
+}
+
+func (c *cachedPPFile) ready() *cachedPPFile            { close(c.readyCh); return c }
+func (c *cachedPPFile) waitFor() (*cachedPPFile, error) { <-c.readyCh; return c, c.err }
+
+func (c *cachedPPFile) ppFile() (*ppFile, error) {
+	c.waitFor()
+	if c.err == nil {
+		return c.pf, nil
+	}
+
+	return nil, c.err
+}
+
+type cacheKey struct {
+	name  StringID
+	sys   bool
+	value StringID
+	Config3
+}
+
+type ppCache struct {
+	mu sync.RWMutex
+	m  map[cacheKey]*cachedPPFile
+}
+
+func newPPCache() *ppCache { return &ppCache{m: map[cacheKey]*cachedPPFile{}} }
+
+func (c *ppCache) get(ctx *context, src Source) (source, error) {
+	if src.Value != "" {
+		return c.getValue(ctx, src.Name, src.Value, false, src.DoNotCache)
+	}
+
+	return c.getFile(ctx, src.Name, false, src.DoNotCache)
+}
+
+func (c *ppCache) getFile(ctx *context, name string, sys bool, doNotCache bool) (*cachedPPFile, error) {
+	fi, err := ctx.statFile(name, sys)
+	if err != nil {
+		return nil, err
+	}
+
+	if !fi.Mode().IsRegular() {
+		return nil, fmt.Errorf("%s is not a regular file", name)
+	}
+
+	if fi.Size() > mathutil.MaxInt {
+		return nil, fmt.Errorf("%s: file too big", name)
+	}
+
+	size := int(fi.Size())
+	if !filepath.IsAbs(name) { // Never cache relative paths
+		f, err := ctx.openFile(name, sys)
+		if err != nil {
+			return nil, err
+		}
+
+		defer f.Close()
+
+		tf := tokenNewFile(name, size)
+		ppFile := newScanner(ctx, f, tf).translationPhase3()
+		cf := &cachedPPFile{pf: ppFile, readyCh: make(chan struct{})}
+		cf.ready()
+		return cf, nil
+	}
+
+	modTime := fi.ModTime().UnixNano()
+	key := cacheKey{dict.sid(name), sys, 0, ctx.cfg.Config3}
+	c.mu.Lock()
+	if cf, ok := c.m[key]; ok {
+		if modTime <= cf.modTime && size == cf.size {
+			c.mu.Unlock()
+			if cf.err != nil {
+				return nil, cf.err
+			}
+
+			r, err := cf.waitFor()
+			ctx.errs(cf.errs)
+			return r, err
+		}
+
+		delete(c.m, key)
+	}
+
+	tf := tokenNewFile(name, size)
+	cf := &cachedPPFile{modTime: modTime, size: size, readyCh: make(chan struct{})}
+	if !doNotCache {
+		c.m[key] = cf
+	}
+	c.mu.Unlock()
+
+	go func() {
+		defer cf.ready()
+
+		f, err := ctx.openFile(name, sys)
+		if err != nil {
+			cf.err = err
+			return
+		}
+
+		defer f.Close()
+
+		ctx2 := newContext(ctx.cfg)
+		cf.pf = newScanner(ctx2, f, tf).translationPhase3()
+		cf.errs = ctx2.ErrorList
+		ctx.errs(cf.errs)
+	}()
+
+	return cf.waitFor()
+}
+
+func (c *ppCache) getValue(ctx *context, name, value string, sys bool, doNotCache bool) (*cachedPPFile, error) {
+	key := cacheKey{dict.sid(name), sys, dict.sid(value), ctx.cfg.Config3}
+	c.mu.Lock()
+	if cf, ok := c.m[key]; ok {
+		c.mu.Unlock()
+		if cf.err != nil {
+			return nil, cf.err
+		}
+
+		r, err := cf.waitFor()
+		ctx.errs(cf.errs)
+		return r, err
+	}
+
+	tf := tokenNewFile(name, len(value))
+	cf := &cachedPPFile{readyCh: make(chan struct{})}
+	if !doNotCache {
+		c.m[key] = cf
+	}
+	c.mu.Unlock()
+	ctx2 := newContext(ctx.cfg)
+	cf.pf = newScanner(ctx2, strings.NewReader(value), tf).translationPhase3()
+	cf.errs = ctx2.ErrorList
+	ctx.errs(cf.errs)
+	cf.ready()
+	return cf.waitFor()
+}