From: Matthew Dempsky Date: Fri, 26 Feb 2016 10:10:29 +0000 (-0800) Subject: cmd/compile: simplify lexinit and lexfini X-Git-Tag: go1.7beta1~1670 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=52f099c4263f2ffd1cda777d7f6ed9689bb481a5;p=gostls13.git cmd/compile: simplify lexinit and lexfini Split the syms array into separate basicTypes and builtinFuncs arrays. Also, in lexfini, instead of duplicating the code from lexinit to declare the builtin identifiers in the user package, just import them from builtinpkg like how importdot works. Change-Id: Ic3b3b454627a46f7bd5f290d0e31443e659d431f Reviewed-on: https://go-review.googlesource.com/19936 Run-TryBot: Matthew Dempsky TryBot-Result: Gobot Gobot Reviewed-by: Robert Griesemer --- diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index 51cee2d851..62cdded120 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -2067,77 +2067,75 @@ func (l *lexer) hexchar(n int) uint32 { return x } -var syms = []struct { +var basicTypes = [...]struct { name string etype EType - op Op }{ - // basic types - {"int8", TINT8, OXXX}, - {"int16", TINT16, OXXX}, - {"int32", TINT32, OXXX}, - {"int64", TINT64, OXXX}, - {"uint8", TUINT8, OXXX}, - {"uint16", TUINT16, OXXX}, - {"uint32", TUINT32, OXXX}, - {"uint64", TUINT64, OXXX}, - {"float32", TFLOAT32, OXXX}, - {"float64", TFLOAT64, OXXX}, - {"complex64", TCOMPLEX64, OXXX}, - {"complex128", TCOMPLEX128, OXXX}, - {"bool", TBOOL, OXXX}, - {"string", TSTRING, OXXX}, - {"any", TANY, OXXX}, - - // builtin funcs - {"append", Txxx, OAPPEND}, - {"cap", Txxx, OCAP}, - {"close", Txxx, OCLOSE}, - {"complex", Txxx, OCOMPLEX}, - {"copy", Txxx, OCOPY}, - {"delete", Txxx, ODELETE}, - {"imag", Txxx, OIMAG}, - {"len", Txxx, OLEN}, - {"make", Txxx, OMAKE}, - {"new", Txxx, ONEW}, - {"panic", Txxx, OPANIC}, - {"print", Txxx, OPRINT}, - {"println", Txxx, OPRINTN}, - {"real", Txxx, OREAL}, - {"recover", Txxx, ORECOVER}, + {"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}, + {"any", TANY}, +} + +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}, } // lexinit initializes known symbols and the basic types. func lexinit() { - for _, s := range syms { - if etype := s.etype; etype != Txxx { - if int(etype) >= len(Types) { - Fatalf("lexinit: %s bad etype", s.name) + for _, s := range basicTypes { + etype := s.etype + if int(etype) >= len(Types) { + Fatalf("lexinit: %s bad etype", s.name) + } + s2 := Pkglookup(s.name, builtinpkg) + t := Types[etype] + if t == nil { + t = typ(etype) + t.Sym = s2 + if etype != TANY && etype != TSTRING { + dowidth(t) } - s2 := Pkglookup(s.name, builtinpkg) - t := Types[etype] - if t == nil { - t = typ(etype) - t.Sym = s2 - - if etype != TANY && etype != TSTRING { - dowidth(t) - } - Types[etype] = t - } - - s2.Def = typenod(t) - s2.Def.Name = new(Name) - continue + Types[etype] = t } + s2.Def = typenod(t) + s2.Def.Name = new(Name) + } + for _, s := range builtinFuncs { // TODO(marvin): Fix Node.EType type union. - if etype := s.op; etype != OXXX { - s2 := Pkglookup(s.name, builtinpkg) - s2.Def = Nod(ONAME, nil, nil) - s2.Def.Sym = s2 - s2.Def.Etype = EType(etype) - } + s2 := Pkglookup(s.name, builtinpkg) + s2.Def = Nod(ONAME, nil, nil) + s2.Def.Sym = s2 + s2.Def.Etype = EType(s.op) } // logically, the type of a string literal. @@ -2183,6 +2181,11 @@ func lexinit() { s.Def = nodlit(v) s.Def.Sym = s s.Def.Name = new(Name) + + s = Pkglookup("iota", builtinpkg) + s.Def = Nod(OIOTA, nil, nil) + s.Def.Sym = s + s.Def.Name = new(Name) } func lexinit1() { @@ -2230,86 +2233,28 @@ func lexinit1() { runetype.Sym = s s.Def = typenod(runetype) s.Def.Name = new(Name) -} - -func lexfini() { - for i := range syms { - s := Lookup(syms[i].name) - - etype := syms[i].etype - if etype != Txxx && (etype != TANY || Debug['A'] != 0) && s.Def == nil { - s.Def = typenod(Types[etype]) - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } - - // TODO(marvin): Fix Node.EType type union. - etype = EType(syms[i].op) - if etype != EType(OXXX) && s.Def == nil { - s.Def = Nod(ONAME, nil, nil) - s.Def.Sym = s - s.Def.Etype = etype - s.Origpkg = builtinpkg - } - } // backend-specific builtin types (e.g. int). for i := range Thearch.Typedefs { - s := Lookup(Thearch.Typedefs[i].Name) - if s.Def == nil { - s.Def = typenod(Types[Thearch.Typedefs[i].Etype]) - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } - } - - // there's only so much table-driven we can handle. - // these are special cases. - if s := Lookup("byte"); s.Def == nil { - s.Def = typenod(bytetype) + s := Pkglookup(Thearch.Typedefs[i].Name, builtinpkg) + s.Def = typenod(Types[Thearch.Typedefs[i].Etype]) s.Def.Name = new(Name) s.Origpkg = builtinpkg } +} - if s := Lookup("error"); s.Def == nil { - s.Def = typenod(errortype) - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } - - if s := Lookup("rune"); s.Def == nil { - s.Def = typenod(runetype) - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } - - if s := Lookup("nil"); s.Def == nil { - var v Val - v.U = new(NilVal) - s.Def = nodlit(v) - s.Def.Sym = s - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } - - if s := Lookup("iota"); s.Def == nil { - s.Def = Nod(OIOTA, nil, nil) - s.Def.Sym = s - s.Origpkg = builtinpkg - } - - if s := Lookup("true"); s.Def == nil { - s.Def = Nodbool(true) - s.Def.Sym = s - s.Def.Name = new(Name) - s.Origpkg = builtinpkg - } +func lexfini() { + for _, s := range builtinpkg.Syms { + if s.Def == nil { + continue + } + s1 := Lookup(s.Name) + if s1.Def != nil { + continue + } - if s := Lookup("false"); s.Def == nil { - s.Def = Nodbool(false) - s.Def.Sym = s - s.Def.Name = new(Name) - s.Origpkg = builtinpkg + s1.Def = s.Def + s1.Block = s.Block } nodfp = Nod(ONAME, nil, nil)