mirror of
https://github.com/autc04/Retro68.git
synced 2024-11-24 07:31:32 +00:00
119 lines
3.4 KiB
Go
119 lines
3.4 KiB
Go
// 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()
|
|
}
|