Gecko [ 167.86.127.34 ]

Name	Size	Permission
builtin	[ DIR ]	drwxr-xr-x
testdata	[ DIR ]	drwxr-xr-x
alg.go	16.28 KB	-rw-r--r--
align.go	9.85 KB	-rw-r--r--
bexport.go	4.41 KB	-rw-r--r--
bimport.go	667 B	-rw-r--r--
bitset.go	1.15 KB	-rw-r--r--
bootstrap.go	311 B	-rw-r--r--
builtin.go	16.41 KB	-rw-r--r--
builtin_test.go	622 B	-rw-r--r--
bv.go	5.5 KB	-rw-r--r--
class_string.go	712 B	-rw-r--r--
closure.go	15.57 KB	-rw-r--r--
const.go	27.21 KB	-rw-r--r--
constFold_test.go	322.99 KB	-rw-r--r--
dcl.go	28.37 KB	-rw-r--r--
dep_test.go	587 B	-rw-r--r--
dump.go	6.37 KB	-rw-r--r--
dwinl.go	10.07 KB	-rw-r--r--
esc.go	12.22 KB	-rw-r--r--
escape.go	37.37 KB	-rw-r--r--
export.go	5.33 KB	-rw-r--r--
fixedbugs_test.go	2.23 KB	-rw-r--r--
float_test.go	11.51 KB	-rw-r--r--
fmt.go	41.71 KB	-rw-r--r--
gen.go	2.33 KB	-rw-r--r--
global_test.go	2.57 KB	-rw-r--r--
go.go	7.4 KB	-rw-r--r--
gsubr.go	9.08 KB	-rw-r--r--
iexport.go	31.65 KB	-rw-r--r--
iface_test.go	1.92 KB	-rw-r--r--
iimport.go	22.79 KB	-rw-r--r--
init.go	3.29 KB	-rw-r--r--
initorder.go	9.84 KB	-rw-r--r--
inl.go	35.08 KB	-rw-r--r--
inl_test.go	6.64 KB	-rw-r--r--
lang_test.go	1.46 KB	-rw-r--r--
lex.go	5.96 KB	-rw-r--r--
lex_test.go	3.63 KB	-rw-r--r--
logic_test.go	11.08 KB	-rw-r--r--
main.go	43.75 KB	-rw-r--r--
mapfile_mmap.go	1.21 KB	-rw-r--r--
mapfile_read.go	485 B	-rw-r--r--
mkbuiltin.go	5.34 KB	-rw-r--r--
mpfloat.go	6.56 KB	-rw-r--r--
mpint.go	5.34 KB	-rw-r--r--
noder.go	37.65 KB	-rw-r--r--
obj.go	11.44 KB	-rw-r--r--
op_string.go	4.88 KB	-rw-r--r--
order.go	37.39 KB	-rw-r--r--
pgen.go	21.66 KB	-rw-r--r--
pgen_test.go	6.01 KB	-rw-r--r--
phi.go	14.72 KB	-rw-r--r--
plive.go	44.51 KB	-rw-r--r--
pprof.go	274 B	-rw-r--r--
racewalk.go	2.61 KB	-rw-r--r--
range.go	13.72 KB	-rw-r--r--
reflect.go	48.07 KB	-rw-r--r--
reproduciblebuilds_test.go	1.46 KB	-rw-r--r--
scc.go	4.18 KB	-rw-r--r--
scope.go	2.8 KB	-rw-r--r--
scope_test.go	13.67 KB	-rw-r--r--
select.go	9.16 KB	-rw-r--r--
shift_test.go	21.46 KB	-rw-r--r--
sinit.go	26.75 KB	-rw-r--r--
sizeof_test.go	844 B	-rw-r--r--
ssa.go	224.4 KB	-rw-r--r--
ssa_test.go	5.1 KB	-rw-r--r--
subr.go	43.73 KB	-rw-r--r--
swt.go	18.51 KB	-rw-r--r--
syntax.go	36.41 KB	-rw-r--r--
timings.go	5.75 KB	-rw-r--r--
trace.go	494 B	-rw-r--r--
truncconst_test.go	1.76 KB	-rw-r--r--
typecheck.go	87.11 KB	-rw-r--r--
types.go	1.19 KB	-rw-r--r--
types_acc.go	491 B	-rw-r--r--
universe.go	10.88 KB	-rw-r--r--
unsafe.go	1.8 KB	-rw-r--r--
util.go	2.18 KB	-rw-r--r--
walk.go	101.89 KB	-rw-r--r--
zerorange_test.go	1.89 KB	-rw-r--r--

Code Editor : universe.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// TODO(gri) This file should probably become part of package types.

package gc

import "cmd/compile/internal/types"

// builtinpkg is a fake package that declares the universe block.
var builtinpkg *types.Pkg

var basicTypes = [...]struct {
	name  string
	etype types.EType
}{
	{"int8", TINT8},
	{"int16", TINT16},
	{"int32", TINT32},
	{"int64", TINT64},
	{"uint8", TUINT8},
	{"uint16", TUINT16},
	{"uint32", TUINT32},
	{"uint64", TUINT64},
	{"float32", TFLOAT32},
	{"float64", TFLOAT64},
	{"complex64", TCOMPLEX64},
	{"complex128", TCOMPLEX128},
	{"bool", TBOOL},
	{"string", TSTRING},
}

var typedefs = [...]struct {
	name     string
	etype    types.EType
	sameas32 types.EType
	sameas64 types.EType
}{
	{"int", TINT, TINT32, TINT64},
	{"uint", TUINT, TUINT32, TUINT64},
	{"uintptr", TUINTPTR, TUINT32, TUINT64},
}

var builtinFuncs = [...]struct {
	name string
	op   Op
}{
	{"append", OAPPEND},
	{"cap", OCAP},
	{"close", OCLOSE},
	{"complex", OCOMPLEX},
	{"copy", OCOPY},
	{"delete", ODELETE},
	{"imag", OIMAG},
	{"len", OLEN},
	{"make", OMAKE},
	{"new", ONEW},
	{"panic", OPANIC},
	{"print", OPRINT},
	{"println", OPRINTN},
	{"real", OREAL},
	{"recover", ORECOVER},
}

// isBuiltinFuncName reports whether name matches a builtin function
// name.
func isBuiltinFuncName(name string) bool {
	for _, fn := range builtinFuncs {
		if fn.name == name {
			return true
		}
	}
	return false
}

var unsafeFuncs = [...]struct {
	name string
	op   Op
}{
	{"Alignof", OALIGNOF},
	{"Offsetof", OOFFSETOF},
	{"Sizeof", OSIZEOF},
}

// initUniverse initializes the universe block.
func initUniverse() {
	lexinit()
	typeinit()
	lexinit1()
}

// lexinit initializes known symbols and the basic types.
func lexinit() {
	for _, s := range basicTypes {
		etype := s.etype
		if int(etype) >= len(types.Types) {
			Fatalf("lexinit: %s bad etype", s.name)
		}
		s2 := builtinpkg.Lookup(s.name)
		t := types.Types[etype]
		if t == nil {
			t = types.New(etype)
			t.Sym = s2
			if etype != TANY && etype != TSTRING {
				dowidth(t)
			}
			types.Types[etype] = t
		}
		s2.Def = asTypesNode(typenod(t))
		asNode(s2.Def).Name = new(Name)
	}

for _, s := range builtinFuncs {
		s2 := builtinpkg.Lookup(s.name)
		s2.Def = asTypesNode(newname(s2))
		asNode(s2.Def).SetSubOp(s.op)
	}

for _, s := range unsafeFuncs {
		s2 := unsafepkg.Lookup(s.name)
		s2.Def = asTypesNode(newname(s2))
		asNode(s2.Def).SetSubOp(s.op)
	}

types.Idealstring = types.New(TSTRING)
	types.Idealbool = types.New(TBOOL)
	types.Types[TANY] = types.New(TANY)

s := builtinpkg.Lookup("true")
	s.Def = asTypesNode(nodbool(true))
	asNode(s.Def).Sym = lookup("true")
	asNode(s.Def).Name = new(Name)
	asNode(s.Def).Type = types.Idealbool

s = builtinpkg.Lookup("false")
	s.Def = asTypesNode(nodbool(false))
	asNode(s.Def).Sym = lookup("false")
	asNode(s.Def).Name = new(Name)
	asNode(s.Def).Type = types.Idealbool

s = lookup("_")
	s.Block = -100
	s.Def = asTypesNode(newname(s))
	types.Types[TBLANK] = types.New(TBLANK)
	asNode(s.Def).Type = types.Types[TBLANK]
	nblank = asNode(s.Def)

s = builtinpkg.Lookup("_")
	s.Block = -100
	s.Def = asTypesNode(newname(s))
	types.Types[TBLANK] = types.New(TBLANK)
	asNode(s.Def).Type = types.Types[TBLANK]

types.Types[TNIL] = types.New(TNIL)
	s = builtinpkg.Lookup("nil")
	var v Val
	v.U = new(NilVal)
	s.Def = asTypesNode(nodlit(v))
	asNode(s.Def).Sym = s
	asNode(s.Def).Name = new(Name)

s = builtinpkg.Lookup("iota")
	s.Def = asTypesNode(nod(OIOTA, nil, nil))
	asNode(s.Def).Sym = s
	asNode(s.Def).Name = new(Name)
}

func typeinit() {
	if Widthptr == 0 {
		Fatalf("typeinit before betypeinit")
	}

for et := types.EType(0); et < NTYPE; et++ {
		simtype[et] = et
	}

types.Types[TPTR] = types.New(TPTR)
	dowidth(types.Types[TPTR])

t := types.New(TUNSAFEPTR)
	types.Types[TUNSAFEPTR] = t
	t.Sym = unsafepkg.Lookup("Pointer")
	t.Sym.Def = asTypesNode(typenod(t))
	asNode(t.Sym.Def).Name = new(Name)
	dowidth(types.Types[TUNSAFEPTR])

for et := TINT8; et <= TUINT64; et++ {
		isInt[et] = true
	}
	isInt[TINT] = true
	isInt[TUINT] = true
	isInt[TUINTPTR] = true

isFloat[TFLOAT32] = true
	isFloat[TFLOAT64] = true

isComplex[TCOMPLEX64] = true
	isComplex[TCOMPLEX128] = true

// initialize okfor
	for et := types.EType(0); et < NTYPE; et++ {
		if isInt[et] || et == TIDEAL {
			okforeq[et] = true
			okforcmp[et] = true
			okforarith[et] = true
			okforadd[et] = true
			okforand[et] = true
			okforconst[et] = true
			issimple[et] = true
			minintval[et] = new(Mpint)
			maxintval[et] = new(Mpint)
		}

if isFloat[et] {
			okforeq[et] = true
			okforcmp[et] = true
			okforadd[et] = true
			okforarith[et] = true
			okforconst[et] = true
			issimple[et] = true
			minfltval[et] = newMpflt()
			maxfltval[et] = newMpflt()
		}

if isComplex[et] {
			okforeq[et] = true
			okforadd[et] = true
			okforarith[et] = true
			okforconst[et] = true
			issimple[et] = true
		}
	}

issimple[TBOOL] = true

okforadd[TSTRING] = true

okforbool[TBOOL] = true

okforcap[TARRAY] = true
	okforcap[TCHAN] = true
	okforcap[TSLICE] = true

okforconst[TBOOL] = true
	okforconst[TSTRING] = true

okforlen[TARRAY] = true
	okforlen[TCHAN] = true
	okforlen[TMAP] = true
	okforlen[TSLICE] = true
	okforlen[TSTRING] = true

okforeq[TPTR] = true
	okforeq[TUNSAFEPTR] = true
	okforeq[TINTER] = true
	okforeq[TCHAN] = true
	okforeq[TSTRING] = true
	okforeq[TBOOL] = true
	okforeq[TMAP] = true    // nil only; refined in typecheck
	okforeq[TFUNC] = true   // nil only; refined in typecheck
	okforeq[TSLICE] = true  // nil only; refined in typecheck
	okforeq[TARRAY] = true  // only if element type is comparable; refined in typecheck
	okforeq[TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck

okforcmp[TSTRING] = true

var i int
	for i = 0; i < len(okfor); i++ {
		okfor[i] = okfornone[:]
	}

// binary
	okfor[OADD] = okforadd[:]
	okfor[OAND] = okforand[:]
	okfor[OANDAND] = okforbool[:]
	okfor[OANDNOT] = okforand[:]
	okfor[ODIV] = okforarith[:]
	okfor[OEQ] = okforeq[:]
	okfor[OGE] = okforcmp[:]
	okfor[OGT] = okforcmp[:]
	okfor[OLE] = okforcmp[:]
	okfor[OLT] = okforcmp[:]
	okfor[OMOD] = okforand[:]
	okfor[OMUL] = okforarith[:]
	okfor[ONE] = okforeq[:]
	okfor[OOR] = okforand[:]
	okfor[OOROR] = okforbool[:]
	okfor[OSUB] = okforarith[:]
	okfor[OXOR] = okforand[:]
	okfor[OLSH] = okforand[:]
	okfor[ORSH] = okforand[:]

// unary
	okfor[OBITNOT] = okforand[:]
	okfor[ONEG] = okforarith[:]
	okfor[ONOT] = okforbool[:]
	okfor[OPLUS] = okforarith[:]

// special
	okfor[OCAP] = okforcap[:]
	okfor[OLEN] = okforlen[:]

// comparison
	iscmp[OLT] = true
	iscmp[OGT] = true
	iscmp[OGE] = true
	iscmp[OLE] = true
	iscmp[OEQ] = true
	iscmp[ONE] = true

maxintval[TINT8].SetString("0x7f")
	minintval[TINT8].SetString("-0x80")
	maxintval[TINT16].SetString("0x7fff")
	minintval[TINT16].SetString("-0x8000")
	maxintval[TINT32].SetString("0x7fffffff")
	minintval[TINT32].SetString("-0x80000000")
	maxintval[TINT64].SetString("0x7fffffffffffffff")
	minintval[TINT64].SetString("-0x8000000000000000")

maxintval[TUINT8].SetString("0xff")
	maxintval[TUINT16].SetString("0xffff")
	maxintval[TUINT32].SetString("0xffffffff")
	maxintval[TUINT64].SetString("0xffffffffffffffff")

// f is valid float if min < f < max.  (min and max are not themselves valid.)
	maxfltval[TFLOAT32].SetString("33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
	minfltval[TFLOAT32].SetString("-33554431p103")
	maxfltval[TFLOAT64].SetString("18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
	minfltval[TFLOAT64].SetString("-18014398509481983p970")

maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
	minfltval[TCOMPLEX64] = minfltval[TFLOAT32]
	maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
	minfltval[TCOMPLEX128] = minfltval[TFLOAT64]

types.Types[TINTER] = types.New(TINTER) // empty interface

// simple aliases
	simtype[TMAP] = TPTR
	simtype[TCHAN] = TPTR
	simtype[TFUNC] = TPTR
	simtype[TUNSAFEPTR] = TPTR

slice_array = int(Rnd(0, int64(Widthptr)))
	slice_nel = int(Rnd(int64(slice_array)+int64(Widthptr), int64(Widthptr)))
	slice_cap = int(Rnd(int64(slice_nel)+int64(Widthptr), int64(Widthptr)))
	sizeof_Slice = int(Rnd(int64(slice_cap)+int64(Widthptr), int64(Widthptr)))

// string is same as slice wo the cap
	sizeof_String = int(Rnd(int64(slice_nel)+int64(Widthptr), int64(Widthptr)))

dowidth(types.Types[TSTRING])
	dowidth(types.Idealstring)
}

func makeErrorInterface() *types.Type {
	field := types.NewField()
	field.Type = types.Types[TSTRING]
	f := functypefield(fakeRecvField(), nil, []*types.Field{field})

field = types.NewField()
	field.Sym = lookup("Error")
	field.Type = f

t := types.New(TINTER)
	t.SetInterface([]*types.Field{field})
	return t
}

func lexinit1() {
	// error type
	s := builtinpkg.Lookup("error")
	types.Errortype = makeErrorInterface()
	types.Errortype.Sym = s
	types.Errortype.Orig = makeErrorInterface()
	s.Def = asTypesNode(typenod(types.Errortype))
	dowidth(types.Errortype)

// We create separate byte and rune types for better error messages
	// rather than just creating type alias *types.Sym's for the uint8 and
	// int32 types. Hence, (bytetype|runtype).Sym.isAlias() is false.
	// TODO(gri) Should we get rid of this special case (at the cost
	// of less informative error messages involving bytes and runes)?
	// (Alternatively, we could introduce an OTALIAS node representing
	// type aliases, albeit at the cost of having to deal with it everywhere).

// byte alias
	s = builtinpkg.Lookup("byte")
	types.Bytetype = types.New(TUINT8)
	types.Bytetype.Sym = s
	s.Def = asTypesNode(typenod(types.Bytetype))
	asNode(s.Def).Name = new(Name)
	dowidth(types.Bytetype)

// rune alias
	s = builtinpkg.Lookup("rune")
	types.Runetype = types.New(TINT32)
	types.Runetype.Sym = s
	s.Def = asTypesNode(typenod(types.Runetype))
	asNode(s.Def).Name = new(Name)
	dowidth(types.Runetype)

// backend-dependent builtin types (e.g. int).
	for _, s := range typedefs {
		s1 := builtinpkg.Lookup(s.name)

sameas := s.sameas32
		if Widthptr == 8 {
			sameas = s.sameas64
		}

simtype[s.etype] = sameas
		minfltval[s.etype] = minfltval[sameas]
		maxfltval[s.etype] = maxfltval[sameas]
		minintval[s.etype] = minintval[sameas]
		maxintval[s.etype] = maxintval[sameas]

t := types.New(s.etype)
		t.Sym = s1
		types.Types[s.etype] = t
		s1.Def = asTypesNode(typenod(t))
		asNode(s1.Def).Name = new(Name)
		s1.Origpkg = builtinpkg

dowidth(t)
	}
}

// finishUniverse makes the universe block visible within the current package.
func finishUniverse() {
	// Operationally, this is similar to a dot import of builtinpkg, except
	// that we silently skip symbols that are already declared in the
	// package block rather than emitting a redeclared symbol error.

for _, s := range builtinpkg.Syms {
		if s.Def == nil {
			continue
		}
		s1 := lookup(s.Name)
		if s1.Def != nil {
			continue
		}

s1.Def = s.Def
		s1.Block = s.Block
	}

nodfp = newname(lookup(".fp"))
	nodfp.Type = types.Types[TINT32]
	nodfp.SetClass(PPARAM)
	nodfp.Name.SetUsed(true)
}

${this.title}

Code Editor : universe.go