1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright 2017 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.
package types
import (
"cmd/compile/internal/base"
"cmd/internal/src"
)
// Declaration stack & operations
var blockgen int32 = 1 // max block number
var Block int32 = 1 // current block number
// A dsym stores a symbol's shadowed declaration so that it can be
// restored once the block scope ends.
type dsym struct {
sym *Sym // sym == nil indicates stack mark
def Object
block int32
lastlineno src.XPos // last declaration for diagnostic
}
// dclstack maintains a stack of shadowed symbol declarations so that
// Popdcl can restore their declarations when a block scope ends.
var dclstack []dsym
// Pushdcl pushes the current declaration for symbol s (if any) so that
// it can be shadowed by a new declaration within a nested block scope.
func Pushdcl(s *Sym) {
dclstack = append(dclstack, dsym{
sym: s,
def: s.Def,
block: s.Block,
lastlineno: s.Lastlineno,
})
}
// Popdcl pops the innermost block scope and restores all symbol declarations
// to their previous state.
func Popdcl() {
for i := len(dclstack); i > 0; i-- {
d := &dclstack[i-1]
s := d.sym
if s == nil {
// pop stack mark
Block = d.block
dclstack = dclstack[:i-1]
return
}
s.Def = d.def
s.Block = d.block
s.Lastlineno = d.lastlineno
// Clear dead pointer fields.
d.sym = nil
d.def = nil
}
base.Fatalf("popdcl: no stack mark")
}
// Markdcl records the start of a new block scope for declarations.
func Markdcl() {
dclstack = append(dclstack, dsym{
sym: nil, // stack mark
block: Block,
})
blockgen++
Block = blockgen
}
func isDclstackValid() bool {
for _, d := range dclstack {
if d.sym == nil {
return false
}
}
return true
}
// PkgDef returns the definition associated with s at package scope.
func (s *Sym) PkgDef() Object {
return *s.pkgDefPtr()
}
// SetPkgDef sets the definition associated with s at package scope.
func (s *Sym) SetPkgDef(n Object) {
*s.pkgDefPtr() = n
}
func (s *Sym) pkgDefPtr() *Object {
// Look for outermost saved declaration, which must be the
// package scope definition, if present.
for i := range dclstack {
d := &dclstack[i]
if s == d.sym {
return &d.def
}
}
// Otherwise, the declaration hasn't been shadowed within a
// function scope.
return &s.Def
}
func CheckDclstack() {
if !isDclstackValid() {
base.Fatalf("mark left on the dclstack")
}
}
|
