| // Copyright 2010 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. |
| |
| // General environment variables. |
| |
| package os |
| |
| import "syscall" |
| |
| // Expand replaces ${var} or $var in the string based on the mapping function. |
| // For example, os.ExpandEnv(s) is equivalent to os.Expand(s, os.Getenv). |
| func Expand(s string, mapping func(string) string) string { |
| buf := make([]byte, 0, 2*len(s)) |
| // ${} is all ASCII, so bytes are fine for this operation. |
| i := 0 |
| for j := 0; j < len(s); j++ { |
| if s[j] == '$' && j+1 < len(s) { |
| buf = append(buf, s[i:j]...) |
| name, w := getShellName(s[j+1:]) |
| buf = append(buf, mapping(name)...) |
| j += w |
| i = j + 1 |
| } |
| } |
| return string(buf) + s[i:] |
| } |
| |
| // ExpandEnv replaces ${var} or $var in the string according to the values |
| // of the current environment variables. References to undefined |
| // variables are replaced by the empty string. |
| func ExpandEnv(s string) string { |
| return Expand(s, Getenv) |
| } |
| |
| // isShellSpecialVar reports whether the character identifies a special |
| // shell variable such as $*. |
| func isShellSpecialVar(c uint8) bool { |
| switch c { |
| case '*', '#', '$', '@', '!', '?', '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': |
| return true |
| } |
| return false |
| } |
| |
| // isAlphaNum reports whether the byte is an ASCII letter, number, or underscore |
| func isAlphaNum(c uint8) bool { |
| return c == '_' || '0' <= c && c <= '9' || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' |
| } |
| |
| // getShellName returns the name that begins the string and the number of bytes |
| // consumed to extract it. If the name is enclosed in {}, it's part of a ${} |
| // expansion and two more bytes are needed than the length of the name. |
| func getShellName(s string) (string, int) { |
| switch { |
| case s[0] == '{': |
| if len(s) > 2 && isShellSpecialVar(s[1]) && s[2] == '}' { |
| return s[1:2], 3 |
| } |
| // Scan to closing brace |
| for i := 1; i < len(s); i++ { |
| if s[i] == '}' { |
| return s[1:i], i + 1 |
| } |
| } |
| return "", 1 // Bad syntax; just eat the brace. |
| case isShellSpecialVar(s[0]): |
| return s[0:1], 1 |
| } |
| // Scan alphanumerics. |
| var i int |
| for i = 0; i < len(s) && isAlphaNum(s[i]); i++ { |
| } |
| return s[:i], i |
| } |
| |
| // Getenv retrieves the value of the environment variable named by the key. |
| // It returns the value, which will be empty if the variable is not present. |
| // To distinguish between an empty value and an unset value, use LookupEnv. |
| func Getenv(key string) string { |
| v, _ := syscall.Getenv(key) |
| return v |
| } |
| |
| // LookupEnv retrieves the value of the environment variable named |
| // by the key. If the variable is present in the environment the |
| // value (which may be empty) is returned and the boolean is true. |
| // Otherwise the returned value will be empty and the boolean will |
| // be false. |
| func LookupEnv(key string) (string, bool) { |
| return syscall.Getenv(key) |
| } |
| |
| // Setenv sets the value of the environment variable named by the key. |
| // It returns an error, if any. |
| func Setenv(key, value string) error { |
| err := syscall.Setenv(key, value) |
| if err != nil { |
| return NewSyscallError("setenv", err) |
| } |
| return nil |
| } |
| |
| // Unsetenv unsets a single environment variable. |
| func Unsetenv(key string) error { |
| return syscall.Unsetenv(key) |
| } |
| |
| // Clearenv deletes all environment variables. |
| func Clearenv() { |
| syscall.Clearenv() |
| } |
| |
| // Environ returns a copy of strings representing the environment, |
| // in the form "key=value". |
| func Environ() []string { |
| return syscall.Environ() |
| } |