"fmt"
"os"
"path/filepath"
"slices"
"strconv"
"strings"
"text/scanner"
"cmd/asm/internal/flags"
"cmd/internal/objabi"
"cmd/internal/src"
"fmt"
"log"
"os"
"strings"
"text/scanner"
"cmd/internal/src"
"text/scanner"
"cmd/internal/src"
"text/scanner"
"cmd/internal/src"
"go/build/constraint"
"io"
"os"
"strings"
"text/scanner"
"unicode"
"cmd/asm/internal/flags"
"cmd/internal/objabi"
"cmd/internal/src"
const ARRconst BuildCommentconst IncludeAsm defines some two-character lexemes. We make up a rune/ScanToken value for them - ugly but simple.
const LSH ScanToken = *ast.BinaryExprconst ROTconst RSHconst macroNamevar panicOnError boolA ScanToken represents an input item. It is a simple wrapping of rune, as returned by text/scanner.Scanner, plus a couple of extra values.
type ScanToken runeA TokenReader is like a reader, but returns lex tokens of type Token. It also can tell you what the text of the most recently returned token is, and where it was found. The underlying scanner elides all spaces except newline, so the input looks like a stream of Tokens; original spacing is lost but we don't need it.
type TokenReader interface {
Next() ScanToken
Text() string
File() string
Base() *src.PosBase
SetBase(*src.PosBase)
Line() int
Col() int
Close()
}Input is the main input: a stack of readers and some macro definitions. It also handles #include processing (by pushing onto the input stack) and parses and instantiates macro definitions.
type Input struct {
Stack
includes []string
beginningOfLine bool
ifdefStack []bool
macros map[string]*Macro
text string
peek bool
peekToken ScanToken
peekText string
}A Macro represents the definition of a #defined macro.
type Macro struct {
name string
args []string
tokens []Token
}A Slice reads from a slice of Tokens.
type Slice struct {
tokens []Token
base *src.PosBase
line int
pos int
}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
}A Token is a scan token plus its string value. A macro is stored as a sequence of Tokens with spaces stripped.
type Token struct {
ScanToken
text string
}A Tokenizer is a simple wrapping of text/scanner.Scanner, configured for our purposes and made a TokenReader. It forms the lowest level, turning text from readers into tokens.
type Tokenizer struct {
tok ScanToken
s *scanner.Scanner
base *src.PosBase
line int
file *os.File
}func (s *Slice) Base() *src.PosBasefunc (t *Tokenizer) Base() *src.PosBasefunc (s *Stack) Base() *src.PosBasefunc (s *Stack) Close()func (t *Tokenizer) Close()func (in *Input) Close()func (s *Slice) Close()func (t *Tokenizer) Col() intfunc (s *Slice) Col() intfunc (s *Stack) Col() intfunc (in *Input) Error(args ...interface{})func (s *Stack) File() stringfunc (t *Tokenizer) File() stringfunc (s *Slice) File() stringIsRegisterShift reports whether the token is one of the ARM register shift operators.
func IsRegisterShift(r ScanToken) boolfunc (t *Tokenizer) Line() intfunc (s *Stack) Line() intfunc (s *Slice) Line() intMake returns a Token with the given rune (ScanToken) and text representation.
func Make(token ScanToken, text string) TokenNewInput returns an Input from the given path.
func NewInput(name string) *InputNewLexer returns a lexer for the named file and the given link context.
func NewLexer(name string) TokenReaderfunc NewSlice(base *src.PosBase, line int, tokens []Token) *Slicefunc NewTokenizer(name string, r io.Reader, file *os.File) *Tokenizerfunc (s *Stack) Next() ScanTokenfunc (in *Input) Next() ScanTokenfunc (t *Tokenizer) Next() ScanTokenfunc (s *Slice) Next() ScanTokenfunc (in *Input) Push(r TokenReader)Push adds tr to the top (end) of the input stack. (Popping happens automatically.)
func (s *Stack) Push(tr TokenReader)func (s *Slice) SetBase(base *src.PosBase)func (t *Tokenizer) SetBase(base *src.PosBase)func (s *Stack) SetBase(base *src.PosBase)func (l Token) String() stringfunc (t ScanToken) String() stringfunc (s *Slice) Text() stringfunc (t *Tokenizer) Text() stringfunc (in *Input) Text() stringfunc (s *Stack) Text() stringTokenize turns a string into a list of Tokens; used to parse the -D flag and in tests.
func Tokenize(str string) []TokenargsFor returns a map from formal name to actual value for this argumented macro invocation. The opening parenthesis has been absorbed.
func (in *Input) argsFor(macro *Macro) map[string][]TokencollectArgument returns the actual tokens for a single argument of a macro. It also returns the token that terminated the argument, which will always be either ',' or ')'. The starting '(' has been scanned.
func (in *Input) collectArgument(macro *Macro) ([]Token, ScanToken)#define processing.
func (in *Input) define()defineMacro stores the macro definition in the Input.
func (in *Input) defineMacro(name string, args []string, tokens []Token)#else processing
func (in *Input) else_()enabled reports whether the input is enabled by an ifdef, or is at the top level.
func (in *Input) enabled() bool#endif processing.
func (in *Input) endif()func (in *Input) expectNewline(directive string)expectText is like Error but adds "got XXX" where XXX is a quoted representation of the most recent token.
func (in *Input) expectText(args ...interface{})hash processes a # preprocessor directive. It reports whether it completes.
func (in *Input) hash() bool#ifdef and #ifndef processing.
func (in *Input) ifdef(truth bool)#include processing.
func (in *Input) include()invokeMacro pushes onto the input Stack a Slice that holds the macro definition with the actual parameters substituted for the formals. Invoking a macro does not touch the PC/line history.
func (in *Input) invokeMacro(macro *Macro)We want center dot (·) and division slash (∕) to work as identifier characters.
func isIdentRune(ch rune, i int) bool#line processing.
func (in *Input) line()macroDefinition returns the list of formals and the tokens of the definition. The argument list is nil for no parens on the definition; otherwise a list of formal argument names.
func (in *Input) macroDefinition(name string) ([]string, []Token)macroName returns the name for the macro being referenced.
func (in *Input) macroName() stringpredefine installs the macros set by the -D flag on the command line.
func predefine(defines flags.MultiFlag) map[string]*Macro#undef processing
func (in *Input) undef()Generated with Arrow