1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef TOOLS_GN_FILESYSTEM_UTILS_H_
6 #define TOOLS_GN_FILESYSTEM_UTILS_H_
7
8 #include <string>
9
10 #include "base/files/file_path.h"
11 #include "base/strings/string_piece.h"
12 #include "tools/gn/settings.h"
13 #include "tools/gn/target.h"
14
15 class Err;
16 class Location;
17 class Value;
18
19 // Returns the extension, not including the dot, for the given file type on the
20 // given system.
21 //
22 // Some targets make multiple files (like a .dll and an import library). This
23 // function returns the name of the file other targets should depend on and
24 // link to (so in this example, the import library).
25 const char* GetExtensionForOutputType(Target::OutputType type,
26 Settings::TargetOS os);
27
28 std::string FilePathToUTF8(const base::FilePath::StringType& str);
FilePathToUTF8(const base::FilePath & path)29 inline std::string FilePathToUTF8(const base::FilePath& path) {
30 return FilePathToUTF8(path.value());
31 }
32 base::FilePath UTF8ToFilePath(const base::StringPiece& sp);
33
34 // Extensions -----------------------------------------------------------------
35
36 // Returns the index of the extension (character after the last dot not after a
37 // slash). Returns std::string::npos if not found. Returns path.size() if the
38 // file ends with a dot.
39 size_t FindExtensionOffset(const std::string& path);
40
41 // Returns a string piece pointing into the input string identifying the
42 // extension. Note that the input pointer must outlive the output.
43 base::StringPiece FindExtension(const std::string* path);
44
45 // Filename parts -------------------------------------------------------------
46
47 // Returns the offset of the character following the last slash, or
48 // 0 if no slash was found. Returns path.size() if the path ends with a slash.
49 // Note that the input pointer must outlive the output.
50 size_t FindFilenameOffset(const std::string& path);
51
52 // Returns a string piece pointing into the input string identifying the
53 // file name (following the last slash, including the extension). Note that the
54 // input pointer must outlive the output.
55 base::StringPiece FindFilename(const std::string* path);
56
57 // Like FindFilename but does not include the extension.
58 base::StringPiece FindFilenameNoExtension(const std::string* path);
59
60 // Removes everything after the last slash. The last slash, if any, will be
61 // preserved.
62 void RemoveFilename(std::string* path);
63
64 // Returns if the given character is a slash. This allows both slashes and
65 // backslashes for consistency between Posix and Windows (as opposed to
66 // FilePath::IsSeparator which is based on the current platform).
IsSlash(const char ch)67 inline bool IsSlash(const char ch) {
68 return ch == '/' || ch == '\\';
69 }
70
71 // Returns true if the given path ends with a slash.
72 bool EndsWithSlash(const std::string& s);
73
74 // Path parts -----------------------------------------------------------------
75
76 // Returns a string piece pointing into the input string identifying the
77 // directory name of the given path, including the last slash. Note that the
78 // input pointer must outlive the output.
79 base::StringPiece FindDir(const std::string* path);
80
81 // Returns the substring identifying the last component of the dir, or the
82 // empty substring if none. For example "//foo/bar/" -> "bar".
83 base::StringPiece FindLastDirComponent(const SourceDir& dir);
84
85 // Verifies that the given string references a file inside of the given
86 // directory. This is pretty stupid and doesn't handle "." and "..", etc.,
87 // it is designed for a sanity check to keep people from writing output files
88 // to the source directory accidentally.
89 //
90 // The origin will be blamed in the error.
91 //
92 // If the file isn't in the dir, returns false and sets the error. Otherwise
93 // returns true and leaves the error untouched.
94 bool EnsureStringIsInOutputDir(const SourceDir& dir,
95 const std::string& str,
96 const ParseNode* origin,
97 Err* err);
98
99 // ----------------------------------------------------------------------------
100
101 // Returns true if the input string is absolute. Double-slashes at the
102 // beginning are treated as source-relative paths. On Windows, this handles
103 // paths of both the native format: "C:/foo" and ours "/C:/foo"
104 bool IsPathAbsolute(const base::StringPiece& path);
105
106 // Given an absolute path, checks to see if is it is inside the source root.
107 // If it is, fills a source-absolute path into the given output and returns
108 // true. If it isn't, clears the dest and returns false.
109 //
110 // The source_root should be a base::FilePath converted to UTF-8. On Windows,
111 // it should begin with a "C:/" rather than being our SourceFile's style
112 // ("/C:/"). The source root can end with a slash or not.
113 //
114 // Note that this does not attempt to normalize slashes in the output.
115 bool MakeAbsolutePathRelativeIfPossible(const base::StringPiece& source_root,
116 const base::StringPiece& path,
117 std::string* dest);
118
119 // Converts a directory to its inverse (e.g. "/foo/bar/" -> "../../").
120 // This will be the empty string for the root directories ("/" and "//"), and
121 // in all other cases, this is guaranteed to end in a slash.
122 std::string InvertDir(const SourceDir& dir);
123
124 // Collapses "." and sequential "/"s and evaluates "..".
125 void NormalizePath(std::string* path);
126
127 // Converts slashes to backslashes for Windows. Keeps the string unchanged
128 // for other systems.
129 void ConvertPathToSystem(std::string* path);
130
131 // Takes a source-absolute path (must begin with "//") and makes it relative
132 // to the given directory, which also must be source-absolute.
133 std::string RebaseSourceAbsolutePath(const std::string& input,
134 const SourceDir& dest_dir);
135
136 // Returns the given directory with no terminating slash at the end, such that
137 // appending a slash and more stuff will produce a valid path.
138 //
139 // If the directory refers to either the source or system root, we'll append
140 // a "." so this remains valid.
141 std::string DirectoryWithNoLastSlash(const SourceDir& dir);
142
143 // Returns the "best" SourceDir representing the given path. If it's inside the
144 // given source_root, a source-relative directory will be returned (e.g.
145 // "//foo/bar.cc". If it's outside of the source root, a system-absolute
146 // directory will be returned.
147 SourceDir SourceDirForPath(const base::FilePath& source_root,
148 const base::FilePath& path);
149
150 // Like SourceDirForPath but returns the SourceDir representing the current
151 // directory.
152 SourceDir SourceDirForCurrentDirectory(const base::FilePath& source_root);
153
154 // Given the label of a toolchain and whether that toolchain is the default
155 // toolchain, returns the name of the subdirectory for that toolchain's
156 // output. This will be the empty string to indicate that the toolchain outputs
157 // go in the root build directory. Otherwise, the result will end in a slash.
158 std::string GetOutputSubdirName(const Label& toolchain_label, bool is_default);
159
160 // -----------------------------------------------------------------------------
161
162 // These functions return the various flavors of output and gen directories.
163 SourceDir GetToolchainOutputDir(const Settings* settings);
164 SourceDir GetToolchainOutputDir(const BuildSettings* build_settings,
165 const Label& label, bool is_default);
166
167 SourceDir GetToolchainGenDir(const Settings* settings);
168 OutputFile GetToolchainGenDirAsOutputFile(const Settings* settings);
169 SourceDir GetToolchainGenDir(const BuildSettings* build_settings,
170 const Label& toolchain_label,
171 bool is_default);
172
173 SourceDir GetOutputDirForSourceDir(const Settings* settings,
174 const SourceDir& source_dir);
175 OutputFile GetOutputDirForSourceDirAsOutputFile(const Settings* settings,
176 const SourceDir& source_dir);
177
178 SourceDir GetGenDirForSourceDir(const Settings* settings,
179 const SourceDir& source_dir);
180 OutputFile GetGenDirForSourceDirAsOutputFile(const Settings* settings,
181 const SourceDir& source_dir);
182
183 SourceDir GetTargetOutputDir(const Target* target);
184 OutputFile GetTargetOutputDirAsOutputFile(const Target* target);
185 SourceDir GetTargetGenDir(const Target* target);
186 OutputFile GetTargetGenDirAsOutputFile(const Target* target);
187
188 SourceDir GetCurrentOutputDir(const Scope* scope);
189 SourceDir GetCurrentGenDir(const Scope* scope);
190
191 #endif // TOOLS_GN_FILESYSTEM_UTILS_H_
192