platform_build_blueprint/scope.go
Dan Willemsen aeffbf776a Allow wrapping of PackageContext
Turn PackageContext into an interface so that build systems can wrap it
to add more custom helpers.

This does introduce an API change, though it should be fairly simple.
NewPackageContext used to provide an opaque *PackageContext struct, now it
provides a PackageContext interface.

Change-Id: I383c64a303d857ef5e0dec86ad77f791ba4c9639
2015-11-30 17:03:34 -08:00

411 lines
9.3 KiB
Go

// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package blueprint
import (
"fmt"
"strings"
"unicode"
"unicode/utf8"
)
// A Variable represents a global Ninja variable definition that will be written
// to the output .ninja file. A variable may contain references to other global
// Ninja variables, but circular variable references are not allowed.
type Variable interface {
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
value(config interface{}) (*ninjaString, error)
String() string
}
// A Pool represents a Ninja pool that will be written to the output .ninja
// file.
type Pool interface {
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
def(config interface{}) (*poolDef, error)
String() string
}
// A Rule represents a Ninja build rule that will be written to the output
// .ninja file.
type Rule interface {
packageContext() *packageContext
name() string // "foo"
fullName(pkgNames map[*packageContext]string) string // "pkg.foo" or "path.to.pkg.foo"
def(config interface{}) (*ruleDef, error)
scope() *basicScope
isArg(argName string) bool
String() string
}
type basicScope struct {
parent *basicScope
variables map[string]Variable
pools map[string]Pool
rules map[string]Rule
imports map[string]*basicScope
}
func newScope(parent *basicScope) *basicScope {
return &basicScope{
parent: parent,
variables: make(map[string]Variable),
pools: make(map[string]Pool),
rules: make(map[string]Rule),
imports: make(map[string]*basicScope),
}
}
func makeRuleScope(parent *basicScope, argNames map[string]bool) *basicScope {
scope := newScope(parent)
for argName := range argNames {
_, err := scope.LookupVariable(argName)
if err != nil {
arg := &argVariable{argName}
err = scope.AddVariable(arg)
if err != nil {
// This should not happen. We should have already checked that
// the name is valid and that the scope doesn't have a variable
// with this name.
panic(err)
}
}
}
// We treat built-in variables like arguments for the purpose of this scope.
for _, builtin := range builtinRuleArgs {
arg := &argVariable{builtin}
err := scope.AddVariable(arg)
if err != nil {
panic(err)
}
}
return scope
}
func (s *basicScope) LookupVariable(name string) (Variable, error) {
dotIndex := strings.IndexRune(name, '.')
if dotIndex >= 0 {
// The variable name looks like "pkg.var"
if dotIndex+1 == len(name) {
return nil, fmt.Errorf("variable name %q ends with a '.'", name)
}
if strings.ContainsRune(name[dotIndex+1:], '.') {
return nil, fmt.Errorf("variable name %q contains multiple '.' "+
"characters", name)
}
pkgName := name[:dotIndex]
varName := name[dotIndex+1:]
first, _ := utf8.DecodeRuneInString(varName)
if !unicode.IsUpper(first) {
return nil, fmt.Errorf("cannot refer to unexported name %q", name)
}
importedScope, err := s.lookupImportedScope(pkgName)
if err != nil {
return nil, err
}
v, ok := importedScope.variables[varName]
if !ok {
return nil, fmt.Errorf("package %q does not contain variable %q",
pkgName, varName)
}
return v, nil
} else {
// The variable name has no package part; just "var"
for ; s != nil; s = s.parent {
v, ok := s.variables[name]
if ok {
return v, nil
}
}
return nil, fmt.Errorf("undefined variable %q", name)
}
}
func (s *basicScope) IsRuleVisible(rule Rule) bool {
_, isBuiltin := rule.(*builtinRule)
if isBuiltin {
return true
}
name := rule.name()
for s != nil {
if s.rules[name] == rule {
return true
}
for _, import_ := range s.imports {
if import_.rules[name] == rule {
return true
}
}
s = s.parent
}
return false
}
func (s *basicScope) IsPoolVisible(pool Pool) bool {
_, isBuiltin := pool.(*builtinPool)
if isBuiltin {
return true
}
name := pool.name()
for s != nil {
if s.pools[name] == pool {
return true
}
for _, import_ := range s.imports {
if import_.pools[name] == pool {
return true
}
}
s = s.parent
}
return false
}
func (s *basicScope) lookupImportedScope(pkgName string) (*basicScope, error) {
for ; s != nil; s = s.parent {
importedScope, ok := s.imports[pkgName]
if ok {
return importedScope, nil
}
}
return nil, fmt.Errorf("unknown imported package %q (missing call to "+
"blueprint.Import()?)", pkgName)
}
func (s *basicScope) AddImport(name string, importedScope *basicScope) error {
_, present := s.imports[name]
if present {
return fmt.Errorf("import %q is already defined in this scope", name)
}
s.imports[name] = importedScope
return nil
}
func (s *basicScope) AddVariable(v Variable) error {
name := v.name()
_, present := s.variables[name]
if present {
return fmt.Errorf("variable %q is already defined in this scope", name)
}
s.variables[name] = v
return nil
}
func (s *basicScope) AddPool(p Pool) error {
name := p.name()
_, present := s.pools[name]
if present {
return fmt.Errorf("pool %q is already defined in this scope", name)
}
s.pools[name] = p
return nil
}
func (s *basicScope) AddRule(r Rule) error {
name := r.name()
_, present := s.rules[name]
if present {
return fmt.Errorf("rule %q is already defined in this scope", name)
}
s.rules[name] = r
return nil
}
type localScope struct {
namePrefix string
scope *basicScope
}
func newLocalScope(parent *basicScope, namePrefix string) *localScope {
return &localScope{
namePrefix: namePrefix,
scope: newScope(parent),
}
}
// ReparentTo sets the localScope's parent scope to the scope of the given
// package context. This allows a ModuleContext and SingletonContext to call
// a function defined in a different Go package and have that function retain
// access to all of the package-scoped variables of its own package.
func (s *localScope) ReparentTo(pctx PackageContext) {
s.scope.parent = pctx.getScope()
}
func (s *localScope) LookupVariable(name string) (Variable, error) {
return s.scope.LookupVariable(name)
}
func (s *localScope) IsRuleVisible(rule Rule) bool {
return s.scope.IsRuleVisible(rule)
}
func (s *localScope) IsPoolVisible(pool Pool) bool {
return s.scope.IsPoolVisible(pool)
}
func (s *localScope) AddLocalVariable(name, value string) (*localVariable,
error) {
err := validateNinjaName(name)
if err != nil {
return nil, err
}
if strings.ContainsRune(name, '.') {
return nil, fmt.Errorf("local variable name %q contains '.'", name)
}
ninjaValue, err := parseNinjaString(s.scope, value)
if err != nil {
return nil, err
}
v := &localVariable{
namePrefix: s.namePrefix,
name_: name,
value_: ninjaValue,
}
err = s.scope.AddVariable(v)
if err != nil {
return nil, err
}
return v, nil
}
func (s *localScope) AddLocalRule(name string, params *RuleParams,
argNames ...string) (*localRule, error) {
err := validateNinjaName(name)
if err != nil {
return nil, err
}
err = validateArgNames(argNames)
if err != nil {
return nil, fmt.Errorf("invalid argument name: %s", err)
}
argNamesSet := make(map[string]bool)
for _, argName := range argNames {
argNamesSet[argName] = true
}
ruleScope := makeRuleScope(s.scope, argNamesSet)
def, err := parseRuleParams(ruleScope, params)
if err != nil {
return nil, err
}
r := &localRule{
namePrefix: s.namePrefix,
name_: name,
def_: def,
argNames: argNamesSet,
scope_: ruleScope,
}
err = s.scope.AddRule(r)
if err != nil {
return nil, err
}
return r, nil
}
type localVariable struct {
namePrefix string
name_ string
value_ *ninjaString
}
func (l *localVariable) packageContext() *packageContext {
return nil
}
func (l *localVariable) name() string {
return l.name_
}
func (l *localVariable) fullName(pkgNames map[*packageContext]string) string {
return l.namePrefix + l.name_
}
func (l *localVariable) value(interface{}) (*ninjaString, error) {
return l.value_, nil
}
func (l *localVariable) String() string {
return "<local var>:" + l.namePrefix + l.name_
}
type localRule struct {
namePrefix string
name_ string
def_ *ruleDef
argNames map[string]bool
scope_ *basicScope
}
func (l *localRule) packageContext() *packageContext {
return nil
}
func (l *localRule) name() string {
return l.name_
}
func (l *localRule) fullName(pkgNames map[*packageContext]string) string {
return l.namePrefix + l.name_
}
func (l *localRule) def(interface{}) (*ruleDef, error) {
return l.def_, nil
}
func (r *localRule) scope() *basicScope {
return r.scope_
}
func (r *localRule) isArg(argName string) bool {
return r.argNames[argName]
}
func (r *localRule) String() string {
return "<local rule>:" + r.namePrefix + r.name_
}