Golang token.Lookup函数代码示例

func (S *Scanner) scanIdentifier() token.Token {
	offs := S.offset
	for isLetter(S.ch) || isDigit(S.ch) {
		S.next()
	}
	return token.Lookup(S.src[offs:S.offset])
}

func (t *enumType) Decls() []ast.Decl {
	typeDecl := &ast.GenDecl{
		Tok: token.TYPE,
		Specs: []ast.Spec{
			&ast.TypeSpec{
				Name: &ast.Ident{Name: t.Name},
				Type: &ast.Ident{Name: t.Type},
			},
		},
		Doc: comment(t.Doc),
	}

	constDecl := &ast.GenDecl{
		Tok:    token.CONST,
		Lparen: 1,
	}
	kind := token.Lookup(t.Type)
	for _, kv := range t.KV {
		constDecl.Specs = append(constDecl.Specs,
			&ast.ValueSpec{
				Names:  []*ast.Ident{{Name: kv.Key}},
				Type:   &ast.Ident{Name: t.Name},
				Values: []ast.Expr{&ast.BasicLit{Kind: kind, Value: kv.Value}},
			})
	}
	return []ast.Decl{typeDecl, constDecl}
}

func (S *Scanner) scanIdentifier() token.Token {
	pos := S.pos.Offset;
	for isLetter(S.ch) || isDigit(S.ch) {
		S.next();
	}
	return token.Lookup(S.src[pos : S.pos.Offset]);
}

func (g *generator) Generate(pkg *model.Package, pkgName string) error {
	g.p("// Automatically generated by MockGen. DO NOT EDIT!")
	if g.filename != "" {
		g.p("// Source: %v", g.filename)
	} else {
		g.p("// Source: %v (interfaces: %v)", g.srcPackage, g.srcInterfaces)
	}
	g.p("")

	// Get all required imports, and generate unique names for them all.
	im := pkg.Imports()
	gomockPath := path.Join(*importPrefix, gomockImportPath)
	im[gomockPath] = true
	g.packageMap = make(map[string]string, len(im))
	localNames := make(map[string]bool, len(im))
	for pth := range im {
		base := sanitize(path.Base(pth))

		// Local names for an imported package can usually be the basename of the import path.
		// A couple of situations don't permit that, such as duplicate local names
		// (e.g. importing "html/template" and "text/template"), or where the basename is
		// a keyword (e.g. "foo/case").
		// try base0, base1, ...
		pkgName := base
		i := 0
		for localNames[pkgName] || token.Lookup(pkgName).IsKeyword() {
			pkgName = base + strconv.Itoa(i)
			i++
		}

		g.packageMap[pth] = pkgName
		localNames[pkgName] = true
	}

	g.p("package %v", pkgName)
	g.p("")
	g.p("import (")
	g.in()
	for path, pkg := range g.packageMap {
		if path == *selfPackage {
			continue
		}
		g.p("%v %q", pkg, path)
	}
	for _, path := range pkg.DotImports {
		g.p(". %q", path)
	}
	g.out()
	g.p(")")

	for _, intf := range pkg.Interfaces {
		if err := g.GenerateMockInterface(intf); err != nil {
			return err
		}
	}

	return nil
}

// NB: for renamings, blank is not considered valid.
func isValidIdentifier(id string) bool {
	if id == "" || id == "_" {
		return false
	}
	for i, r := range id {
		if !isLetter(r) && (i == 0 || !isDigit(r)) {
			return false
		}
	}
	return token.Lookup(id) == token.IDENT
}

func cmdName(val reflect.Value) string {
	mustBeStruct(val)
	typ := val.Type()
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		tag := string(field.Tag)
		if field.Name == "name" &&
			field.Type.Kind() == reflect.String &&
			token.Lookup(tag) == token.IDENT {

			return tag
		}
	}
	return typ.Name()
}

func (self *BridgeFunc) ConvertParam(name, t string) {
	if tok := token.Lookup(name); tok.IsKeyword() {
		name = name + "_"
	}
	self.ParamNames = append(self.ParamNames, name)
	mapFunc, ok := PARAM_MAPPINGS[t]
	if !ok {
		mapFunc = tryDirectMapParam(t)
		if mapFunc == nil {
			log.Fatalf("no map for param type %s: %s", t, self.CFunc.Name)
		}
	}
	mappedName, mappedType, helperCodes := mapFunc(name)
	self.CgoArguments = append(self.CgoArguments, mappedName)
	self.ParamTypes = append(self.ParamTypes, mappedType)
	self.HelperCodes = append(self.HelperCodes, helperCodes...)
}

// Scan scans the next token and returns the token position, the token,
// and its literal string if applicable. The source end is indicated by
// token.EOF.
//
// If the returned token is a literal (token.IDENT, token.INT, token.FLOAT,
// token.IMAG, token.CHAR, token.STRING) or token.COMMENT, the literal string
// has the corresponding value.
//
// If the returned token is token.SEMICOLON, the corresponding
// literal string is ";" if the semicolon was present in the source,
// and "\n" if the semicolon was inserted because of a newline or
// at EOF.
//
// If the returned token is token.ILLEGAL, the literal string is the
// offending character.
//
// In all other cases, Scan returns an empty literal string.
//
// For more tolerant parsing, Scan will return a valid token if
// possible even if a syntax error was encountered. Thus, even
// if the resulting token sequence contains no illegal tokens,
// a client may not assume that no error occurred. Instead it
// must check the scanner's ErrorCount or the number of calls
// of the error handler, if there was one installed.
//
// Scan adds line information to the file added to the file
// set with Init. Token positions are relative to that file
// and thus relative to the file set.
//
func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
scanAgain:
	s.skipWhitespace()

	// current token start
	pos = s.file.Pos(s.offset)

	// determine token value
	insertSemi := false
	switch ch := s.ch; {
	case isLetter(ch):
		lit = s.scanIdentifier()
		tok = token.Lookup(lit)
		switch tok {
		case token.IDENT, token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN:
			insertSemi = true
		}
	case digitVal(ch) < 10:
		insertSemi = true
		tok, lit = s.scanNumber(false)
	default:
		s.next() // always make progress
		switch ch {
		case -1:
			if s.insertSemi {
				s.insertSemi = false // EOF consumed
				return pos, token.SEMICOLON, "\n"
			}
			tok = token.EOF
		case '\n':
			// we only reach here if s.insertSemi was
			// set in the first place and exited early
			// from s.skipWhitespace()
			s.insertSemi = false // newline consumed
			return pos, token.SEMICOLON, "\n"
		case '"':
			insertSemi = true
			tok = token.STRING
			lit = s.scanString()
		case '\'':
			insertSemi = true
			tok = token.CHAR
			lit = s.scanChar()
		case '`':
			insertSemi = true
			tok = token.STRING
			lit = s.scanRawString()
		case ':':
			tok = s.switch2(token.COLON, token.DEFINE)
		case '.':
			if digitVal(s.ch) < 10 {
				insertSemi = true
				tok, lit = s.scanNumber(true)
			} else if s.ch == '.' {
				s.next()
				if s.ch == '.' {
					s.next()
					tok = token.ELLIPSIS
				}
			} else {
				tok = token.PERIOD
			}
		case ',':
			tok = token.COMMA
		case ';':
			tok = token.SEMICOLON
			lit = ";"
		case '(':
			tok = token.LPAREN
		case ')':
			insertSemi = true
//.........这里部分代码省略.........

// Struct conversion: return Go and (gc) C syntax for type.
func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.StructType, csyntax string, align int64) {
	// Minimum alignment for a struct is 1 byte.
	align = 1

	var buf bytes.Buffer
	buf.WriteString("struct {")
	fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field
	off := int64(0)

	// Rename struct fields that happen to be named Go keywords into
	// _{keyword}.  Create a map from C ident -> Go ident.  The Go ident will
	// be mangled.  Any existing identifier that already has the same name on
	// the C-side will cause the Go-mangled version to be prefixed with _.
	// (e.g. in a struct with fields '_type' and 'type', the latter would be
	// rendered as '__type' in Go).
	ident := make(map[string]string)
	used := make(map[string]bool)
	for _, f := range dt.Field {
		ident[f.Name] = f.Name
		used[f.Name] = true
	}

	if !*godefs {
		for cid, goid := range ident {
			if token.Lookup(goid).IsKeyword() {
				// Avoid keyword
				goid = "_" + goid

				// Also avoid existing fields
				for _, exist := used[goid]; exist; _, exist = used[goid] {
					goid = "_" + goid
				}

				used[goid] = true
				ident[cid] = goid
			}
		}
	}

	anon := 0
	for _, f := range dt.Field {
		if f.ByteOffset > off {
			fld = c.pad(fld, f.ByteOffset-off)
			off = f.ByteOffset
		}

		name := f.Name
		ft := f.Type

		// In godefs mode, if this field is a C11
		// anonymous union then treat the first field in the
		// union as the field in the struct.  This handles
		// cases like the glibc <sys/resource.h> file; see
		// issue 6677.
		if *godefs {
			if st, ok := f.Type.(*dwarf.StructType); ok && name == "" && st.Kind == "union" && len(st.Field) > 0 && !used[st.Field[0].Name] {
				name = st.Field[0].Name
				ident[name] = name
				ft = st.Field[0].Type
			}
		}

		// TODO: Handle fields that are anonymous structs by
		// promoting the fields of the inner struct.

		t := c.Type(ft, pos)
		tgo := t.Go
		size := t.Size
		talign := t.Align
		if f.BitSize > 0 {
			if f.BitSize%8 != 0 {
				continue
			}
			size = f.BitSize / 8
			name := tgo.(*ast.Ident).String()
			if strings.HasPrefix(name, "int") {
				name = "int"
			} else {
				name = "uint"
			}
			tgo = ast.NewIdent(name + fmt.Sprint(f.BitSize))
			talign = size
		}

		if talign > 0 && f.ByteOffset%talign != 0 {
			// Drop misaligned fields, the same way we drop integer bit fields.
			// The goal is to make available what can be made available.
			// Otherwise one bad and unneeded field in an otherwise okay struct
			// makes the whole program not compile. Much of the time these
			// structs are in system headers that cannot be corrected.
			continue
		}
		n := len(fld)
		fld = fld[0 : n+1]
		if name == "" {
			name = fmt.Sprintf("anon%d", anon)
			anon++
			ident[name] = name
		}
//.........这里部分代码省略.........

// Struct conversion: return Go and (6g) C syntax for type.
func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.StructType, csyntax string, align int64) {
	var buf bytes.Buffer
	buf.WriteString("struct {")
	fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field
	off := int64(0)

	// Rename struct fields that happen to be named Go keywords into
	// _{keyword}.  Create a map from C ident -> Go ident.  The Go ident will
	// be mangled.  Any existing identifier that already has the same name on
	// the C-side will cause the Go-mangled version to be prefixed with _.
	// (e.g. in a struct with fields '_type' and 'type', the latter would be
	// rendered as '__type' in Go).
	ident := make(map[string]string)
	used := make(map[string]bool)
	for _, f := range dt.Field {
		ident[f.Name] = f.Name
		used[f.Name] = true
	}

	if !*godefs && !*cdefs {
		for cid, goid := range ident {
			if token.Lookup(goid).IsKeyword() {
				// Avoid keyword
				goid = "_" + goid

				// Also avoid existing fields
				for _, exist := used[goid]; exist; _, exist = used[goid] {
					goid = "_" + goid
				}

				used[goid] = true
				ident[cid] = goid
			}
		}
	}

	anon := 0
	for _, f := range dt.Field {
		if f.ByteOffset > off {
			fld = c.pad(fld, f.ByteOffset-off)
			off = f.ByteOffset
		}
		t := c.Type(f.Type, pos)
		tgo := t.Go
		size := t.Size

		if f.BitSize > 0 {
			if f.BitSize%8 != 0 {
				continue
			}
			size = f.BitSize / 8
			name := tgo.(*ast.Ident).String()
			if strings.HasPrefix(name, "int") {
				name = "int"
			} else {
				name = "uint"
			}
			tgo = ast.NewIdent(name + fmt.Sprint(f.BitSize))
		}

		n := len(fld)
		fld = fld[0 : n+1]
		name := f.Name
		if name == "" {
			name = fmt.Sprintf("anon%d", anon)
			anon++
			ident[name] = name
		}
		fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[name])}, Type: tgo}
		off += size
		buf.WriteString(t.C.String())
		buf.WriteString(" ")
		buf.WriteString(name)
		buf.WriteString("; ")
		if t.Align > align {
			align = t.Align
		}
	}
	if off < dt.ByteSize {
		fld = c.pad(fld, dt.ByteSize-off)
		off = dt.ByteSize
	}
	if off != dt.ByteSize {
		fatalf("%s: struct size calculation error off=%d bytesize=%d", lineno(pos), off, dt.ByteSize)
	}
	buf.WriteString("}")
	csyntax = buf.String()

	if *godefs || *cdefs {
		godefsFields(fld)
	}
	expr = &ast.StructType{Fields: &ast.FieldList{List: fld}}
	return
}

// Struct conversion: return Go and (6g) C syntax for type.
func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax string, align int64) {
	var buf bytes.Buffer
	buf.WriteString("struct {")
	fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field
	off := int64(0)

	// Rename struct fields that happen to be named Go keywords into
	// _{keyword}.  Create a map from C ident -> Go ident.  The Go ident will
	// be mangled.  Any existing identifier that already has the same name on
	// the C-side will cause the Go-mangled version to be prefixed with _.
	// (e.g. in a struct with fields '_type' and 'type', the latter would be
	// rendered as '__type' in Go).
	ident := make(map[string]string)
	used := make(map[string]bool)
	for _, f := range dt.Field {
		ident[f.Name] = f.Name
		used[f.Name] = true
	}
	for cid, goid := range ident {
		if token.Lookup([]byte(goid)).IsKeyword() {
			// Avoid keyword
			goid = "_" + goid

			// Also avoid existing fields
			for _, exist := used[goid]; exist; _, exist = used[goid] {
				goid = "_" + goid
			}

			used[goid] = true
			ident[cid] = goid
		}
	}

	for _, f := range dt.Field {
		if f.BitSize > 0 && f.BitSize != f.ByteSize*8 {
			continue
		}
		if f.ByteOffset > off {
			fld = c.pad(fld, f.ByteOffset-off)
			off = f.ByteOffset
		}
		t := c.Type(f.Type)
		n := len(fld)
		fld = fld[0 : n+1]

		fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go}
		off += t.Size
		buf.WriteString(t.C.String())
		buf.WriteString(" ")
		buf.WriteString(f.Name)
		buf.WriteString("; ")
		if t.Align > align {
			align = t.Align
		}
	}
	if off < dt.ByteSize {
		fld = c.pad(fld, dt.ByteSize-off)
		off = dt.ByteSize
	}
	if off != dt.ByteSize {
		fatalf("struct size calculation error")
	}
	buf.WriteString("}")
	csyntax = buf.String()
	expr = &ast.StructType{Fields: &ast.FieldList{List: fld}}
	return
}

func prepareParam(f Func, pi int) Param {
	p := f.Param[pi]

	// Qt seems to have gratuitously changed some names.
	if name, ok := paramNameFixes[p.Name]; ok {
		p.Name = name
	}
	if pi > 0 && strings.HasPrefix(f.GoName, "Uniform") && p.Name != "count" && p.Name != "transpose" {
		if strings.HasSuffix(f.GoName, "v") {
			p.Name = "value"
		} else if f.Param[1].Name == "count" {
			p.Name = "v" + string('0'+pi-2)
		} else {
			p.Name = "v" + string('0'+pi-1)
		}
	}

	// Other names conflict with Go keywords.
	switch p.Name {
	case "type", "func", "map", "string":
		p.GoName = "gl" + p.Name
	default:
		if token.Lookup(p.Name) != token.IDENT {
			p.GoName = p.Name + "_"
		} else {
			p.GoName = p.Name
		}
	}

	// Some consistency. Those are a gl* function after all.
	switch p.Type {
	case "void":
		p.Type = "GLvoid"
	case "char":
		p.Type = "GLchar"
	case "qopengl_GLsizeiptr", "qopengl_GLintptr":
		p.Type = p.Type[8:]
	}

	// Prepare the parameter type.
	p.GoType = goTypeName(p.Type)
	switch p.GoType {
	case "uint32":
		switch p.GoName {
		case "program", "programs":
			p.GoType = "glbase.Program"
		case "shader", "shaders":
			p.GoType = "glbase.Shader"
		case "buffer", "buffers":
			p.GoType = "glbase.Buffer"
		case "texture", "textures":
			p.GoType = "glbase.Texture"
		case "framebuffer", "framebuffers":
			p.GoType = "glbase.Framebuffer"
		case "renderbuffer", "renderbuffers":
			p.GoType = "glbase.Renderbuffer"
		case "index":
			if strings.Contains(f.Name, "Attrib") {
				p.GoType = "glbase.Attrib"
			}
		}
	case "int32":
		switch p.GoName {
		case "size", "count", "stride", "offset", "xoffset", "yoffset", "order", "level":
			p.GoType = "int"
		case "n", "first", "width", "height", "border", "imageSize":
			p.GoType = "int"
		case "x", "y", "z", "w":
			if !strings.HasPrefix(f.GoName, "Uniform") {
				p.GoType = "int"
			}
		case "location":
			if strings.Contains(f.Name, "Uniform") {
				p.GoType = "glbase.Uniform"
			}
		}
	}

	// Save the original name so that future tweaks can still refer
	// to it, and apply the tweaks.
	p.GoNameOrig = p.GoName
	tweak := funcTweaks[f.GoName].params[p.GoNameOrig]
	if tweak.retype != "" {
		p.GoType = tweak.retype
	}
	if tweak.rename != "" {
		p.GoName = tweak.rename
	}

	return p
}

func javaToGoIdentifier(s string) (z string) {
	if token.Lookup(s).IsKeyword() {
		return s + "_gen"
	}
	return s
}

func prepareHeader(header *Header) {
	funcNameDocCount := make(map[string]int)

	for fi, f := range header.Func {
		docPrefix := funcNameDocPrefix(f.Name)
		if docPrefix != f.Name {
			funcNameDocCount[docPrefix]++
		}

		if !strings.HasPrefix(f.Name, "gl") || len(f.Name) < 3 {
			panic("unexpected C function name: " + f.Name)
		}
		f.GoName = f.Name[2:]
		if f.Type != "void" {
			f.GoType = goTypeName(f.Type)
		}

		for pi, p := range f.Param {
			switch p.Name {
			case "type", "func", "map":
				p.GoName = "gl" + p.Name
			default:
				if token.Lookup(p.Name) != token.IDENT {
					p.GoName = p.Name + "_"
				} else {
					p.GoName = p.Name
				}
			}
			p.GoType = goTypeName(p.Type)
			f.Param[pi] = p
		}
		header.Func[fi] = f
	}

	for fi, f := range header.Func {
		prefix := funcNameDocPrefix(f.Name)
		if funcNameDocCount[prefix] > 1 {
			f.DocName = prefix
		} else {
			f.DocName = f.Name
		}
		header.Func[fi] = f
	}

	for ti, t := range header.Type {
		t.GoName = goTypeName(t.Name)
		header.Type[ti] = t
	}

	for di, d := range header.Define {
		if !strings.HasPrefix(d.Name, "GL") || len(d.Name) < 3 {
			panic("unexpected C define name: " + d.Name)
		}
		if d.Name[3] >= '0' && d.Name[3] <= '9' {
			d.GoName = "N" + d.Name[3:]
		} else {
			d.GoName = d.Name[3:]
		}
		header.Define[di] = d
	}
}

func paramName(cparamName string) string {
	if token.Lookup(cparamName) != token.IDENT {
		return cparamName + "_"
	}
	return cparamName
}