if macro.args == nil {
		in.Push(NewSlice(in.Base(), in.Line(), macro.tokens))
		return
	}
	tok := in.Stack.Next()
	if tok != '(' {
		// If the macro has arguments but is invoked without them, all we push is the macro name.
		// First, put back the token.
		in.peekToken = tok
		in.peekText = in.text
		in.peek = true
		in.Push(NewSlice(in.Base(), in.Line(), []Token{Make(macroName, macro.name)}))

pkg debug/elf, const R_386_TLS_GD_PUSH = 25
pkg debug/elf, const R_386_TLS_GOTIE = 16
pkg debug/elf, const R_386_TLS_IE = 15
pkg debug/elf, const R_386_TLS_IE_32 = 33
pkg debug/elf, const R_386_TLS_LDM = 19
pkg debug/elf, const R_386_TLS_LDM_32 = 28
pkg debug/elf, const R_386_TLS_LDM_CALL = 30
pkg debug/elf, const R_386_TLS_LDM_POP = 31
pkg debug/elf, const R_386_TLS_LDM_PUSH = 29
pkg debug/elf, const R_386_TLS_LDO_32 = 32

pkg net/http, method (*Server) Close() error
pkg net/http, method (*Server) Shutdown(context.Context) error
pkg net/http, type Pusher interface { Push }
pkg net/http, type Pusher interface, Push(string, *PushOptions) error
pkg net/http, type PushOptions struct
pkg net/http, type PushOptions struct, Header Header
pkg net/http, type PushOptions struct, Method string

			const argc = this.argv.length;

			const argvPtrs = [];
			this.argv.forEach((arg) => {
				argvPtrs.push(strPtr(arg));
			});
			argvPtrs.push(0);

			const keys = Object.keys(this.env).sort();
			keys.forEach((key) => {
				argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
			});
			argvPtrs.push(0);

			const argv = offset;
			argvPtrs.forEach((ptr) => {
				this.mem.setUint32(offset, ptr, true);

pkg container/heap, func Init(Interface)
pkg container/heap, func Pop(Interface) interface{}
pkg container/heap, func Push(Interface, interface{})
pkg container/heap, func Remove(Interface, int) interface{}
pkg container/heap, type Interface interface { Len, Less, Pop, Push, Swap }
pkg container/heap, type Interface interface, Len() int
pkg container/heap, type Interface interface, Less(int, int) bool

			if err := adb("exec-out", "mkdir", "-p", path.Dir(deviceModDir)); err != nil {
				return 0, err
			}
			// We use a single recursive 'adb push' of the module root instead of
			// walking the tree and copying it piecewise. If the directory tree
			// contains nested modules this could push a lot of unnecessary contents,
			// but for the golang.org/x repos it seems to be significantly (~2x)

)

// A Stack is a stack of TokenReaders. As the top TokenReader hits EOF,
// it resumes reading the next one down.
type Stack struct {
	tr []TokenReader
}

// Push adds tr to the top (end) of the input stack. (Popping happens automatically.)
func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()

pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE = 23 #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE R_LARCH #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_DUP = 24 #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_DUP R_LARCH #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL = 25 #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL R_LARCH #46229
pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL = 22 #46229

			"#define A #define B (x) x",
			"A",
			"B(THIS)",
		),
		"x.\n",
	},
	*/
}

func TestLex(t *testing.T) {
	for _, test := range lexTests {
		input := NewInput(test.name)
		input.Push(NewTokenizer(test.name, strings.NewReader(test.input), nil))
		result := drain(input)
		if result != test.output {
			t.Errorf("%s: got %q expected %q", test.name, result, test.output)
		}
	}
}

// NewLexer returns a lexer for the named file and the given link context.
func NewLexer(name string) TokenReader {
	input := NewInput(name)
	fd, err := os.Open(name)
	if err != nil {
		log.Fatalf("%s\n", err)
	}
	input.Push(NewTokenizer(name, fd, fd))
	return input
}

// The other files in this directory each contain an implementation of TokenReader.