...
Run Format

Source file src/cmd/compile/internal/types/scope.go

Documentation: cmd/compile/internal/types

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

View as plain text