env.go

Documentation: os

		 1  // Copyright 2010 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  // General environment variables.
		 6  
		 7  package os
		 8  
		 9  import (
		10  	"internal/testlog"
		11  	"syscall"
		12  )
		13  
		14  // Expand replaces ${var} or $var in the string based on the mapping function.
		15  // For example, os.ExpandEnv(s) is equivalent to os.Expand(s, os.Getenv).
		16  func Expand(s string, mapping func(string) string) string {
		17  	var buf []byte
		18  	// ${} is all ASCII, so bytes are fine for this operation.
		19  	i := 0
		20  	for j := 0; j < len(s); j++ {
		21  		if s[j] == '$' && j+1 < len(s) {
		22  			if buf == nil {
		23  				buf = make([]byte, 0, 2*len(s))
		24  			}
		25  			buf = append(buf, s[i:j]...)
		26  			name, w := getShellName(s[j+1:])
		27  			if name == "" && w > 0 {
		28  				// Encountered invalid syntax; eat the
		29  				// characters.
		30  			} else if name == "" {
		31  				// Valid syntax, but $ was not followed by a
		32  				// name. Leave the dollar character untouched.
		33  				buf = append(buf, s[j])
		34  			} else {
		35  				buf = append(buf, mapping(name)...)
		36  			}
		37  			j += w
		38  			i = j + 1
		39  		}
		40  	}
		41  	if buf == nil {
		42  		return s
		43  	}
		44  	return string(buf) + s[i:]
		45  }
		46  
		47  // ExpandEnv replaces ${var} or $var in the string according to the values
		48  // of the current environment variables. References to undefined
		49  // variables are replaced by the empty string.
		50  func ExpandEnv(s string) string {
		51  	return Expand(s, Getenv)
		52  }
		53  
		54  // isShellSpecialVar reports whether the character identifies a special
		55  // shell variable such as $*.
		56  func isShellSpecialVar(c uint8) bool {
		57  	switch c {
		58  	case '*', '#', '$', '@', '!', '?', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		59  		return true
		60  	}
		61  	return false
		62  }
		63  
		64  // isAlphaNum reports whether the byte is an ASCII letter, number, or underscore
		65  func isAlphaNum(c uint8) bool {
		66  	return c == '_' || '0' <= c && c <= '9' || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z'
		67  }
		68  
		69  // getShellName returns the name that begins the string and the number of bytes
		70  // consumed to extract it. If the name is enclosed in {}, it's part of a ${}
		71  // expansion and two more bytes are needed than the length of the name.
		72  func getShellName(s string) (string, int) {
		73  	switch {
		74  	case s[0] == '{':
		75  		if len(s) > 2 && isShellSpecialVar(s[1]) && s[2] == '}' {
		76  			return s[1:2], 3
		77  		}
		78  		// Scan to closing brace
		79  		for i := 1; i < len(s); i++ {
		80  			if s[i] == '}' {
		81  				if i == 1 {
		82  					return "", 2 // Bad syntax; eat "${}"
		83  				}
		84  				return s[1:i], i + 1
		85  			}
		86  		}
		87  		return "", 1 // Bad syntax; eat "${"
		88  	case isShellSpecialVar(s[0]):
		89  		return s[0:1], 1
		90  	}
		91  	// Scan alphanumerics.
		92  	var i int
		93  	for i = 0; i < len(s) && isAlphaNum(s[i]); i++ {
		94  	}
		95  	return s[:i], i
		96  }
		97  
		98  // Getenv retrieves the value of the environment variable named by the key.
		99  // It returns the value, which will be empty if the variable is not present.
	 100  // To distinguish between an empty value and an unset value, use LookupEnv.
	 101  func Getenv(key string) string {
	 102  	testlog.Getenv(key)
	 103  	v, _ := syscall.Getenv(key)
	 104  	return v
	 105  }
	 106  
	 107  // LookupEnv retrieves the value of the environment variable named
	 108  // by the key. If the variable is present in the environment the
	 109  // value (which may be empty) is returned and the boolean is true.
	 110  // Otherwise the returned value will be empty and the boolean will
	 111  // be false.
	 112  func LookupEnv(key string) (string, bool) {
	 113  	testlog.Getenv(key)
	 114  	return syscall.Getenv(key)
	 115  }
	 116  
	 117  // Setenv sets the value of the environment variable named by the key.
	 118  // It returns an error, if any.
	 119  func Setenv(key, value string) error {
	 120  	err := syscall.Setenv(key, value)
	 121  	if err != nil {
	 122  		return NewSyscallError("setenv", err)
	 123  	}
	 124  	return nil
	 125  }
	 126  
	 127  // Unsetenv unsets a single environment variable.
	 128  func Unsetenv(key string) error {
	 129  	return syscall.Unsetenv(key)
	 130  }
	 131  
	 132  // Clearenv deletes all environment variables.
	 133  func Clearenv() {
	 134  	syscall.Clearenv()
	 135  }
	 136  
	 137  // Environ returns a copy of strings representing the environment,
	 138  // in the form "key=value".
	 139  func Environ() []string {
	 140  	return syscall.Environ()
	 141  }
	 142
View as plain text