1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright 2017 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 build
import (
"os"
"path/filepath"
"strings"
)
func absPath(ctx Context, p string) string {
ret, err := filepath.Abs(p)
if err != nil {
ctx.Fatalf("Failed to get absolute path: %v", err)
}
return ret
}
// indexList finds the index of a string in a []string
func indexList(s string, list []string) int {
for i, l := range list {
if l == s {
return i
}
}
return -1
}
// inList determines whether a string is in a []string
func inList(s string, list []string) bool {
return indexList(s, list) != -1
}
// removeFromlist removes all occurrences of the string in list.
func removeFromList(s string, list []string) []string {
filteredList := make([]string, 0, len(list))
for _, ls := range list {
if s != ls {
filteredList = append(filteredList, ls)
}
}
return filteredList
}
// ensureDirectoriesExist is a shortcut to os.MkdirAll, sending errors to the ctx logger.
func ensureDirectoriesExist(ctx Context, dirs ...string) {
for _, dir := range dirs {
err := os.MkdirAll(dir, 0777)
if err != nil {
ctx.Fatalf("Error creating %s: %q\n", dir, err)
}
}
}
// ensureEmptyDirectoriesExist ensures that the given directories exist and are empty
func ensureEmptyDirectoriesExist(ctx Context, dirs ...string) {
// remove all the directories
for _, dir := range dirs {
seenErr := map[string]bool{}
for {
err := os.RemoveAll(dir)
if err == nil {
break
}
if pathErr, ok := err.(*os.PathError); !ok ||
dir == pathErr.Path || seenErr[pathErr.Path] {
ctx.Fatalf("Error removing %s: %q\n", dir, err)
} else {
seenErr[pathErr.Path] = true
err = os.Chmod(filepath.Dir(pathErr.Path), 0700)
if err != nil {
ctx.Fatal(err)
}
}
}
}
// recreate all the directories
ensureDirectoriesExist(ctx, dirs...)
}
// ensureEmptyFileExists ensures that the containing directory exists, and the
// specified file exists. If it doesn't exist, it will write an empty file.
func ensureEmptyFileExists(ctx Context, file string) {
ensureDirectoriesExist(ctx, filepath.Dir(file))
if _, err := os.Stat(file); os.IsNotExist(err) {
f, err := os.Create(file)
if err != nil {
ctx.Fatalf("Error creating %s: %q\n", file, err)
}
f.Close()
} else if err != nil {
ctx.Fatalf("Error checking %s: %q\n", file, err)
}
}
// singleUnquote is similar to strconv.Unquote, but can handle multi-character strings inside single quotes.
func singleUnquote(str string) (string, bool) {
if len(str) < 2 || str[0] != '\'' || str[len(str)-1] != '\'' {
return "", false
}
return str[1 : len(str)-1], true
}
// decodeKeyValue decodes a key=value string
func decodeKeyValue(str string) (string, string, bool) {
idx := strings.IndexRune(str, '=')
if idx == -1 {
return "", "", false
}
return str[:idx], str[idx+1:], true
}
|
