| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "tools/gn/build_settings.h" |
| #include "tools/gn/filesystem_utils.h" |
| #include "tools/gn/functions.h" |
| #include "tools/gn/parse_tree.h" |
| #include "tools/gn/scope.h" |
| #include "tools/gn/settings.h" |
| #include "tools/gn/source_dir.h" |
| #include "tools/gn/source_file.h" |
| #include "tools/gn/value.h" |
| |
| namespace functions { |
| |
| namespace { |
| |
| enum SeparatorConversion { |
| SEP_TO_SLASH, // All slashes to forward. |
| SEP_TO_SYSTEM, // Slashes to system ones. |
| }; |
| |
| // Does the specified path separator conversion in-place. |
| void ConvertSlashes(std::string* str, SeparatorConversion mode) { |
| #if defined(OS_WIN) |
| if (mode == SEP_TO_SYSTEM) |
| std::replace(str->begin(), str->end(), '/', '\\'); |
| else |
| #endif |
| if (mode == SEP_TO_SLASH) |
| std::replace(str->begin(), str->end(), '\\', '/'); |
| } |
| |
| // We want the output to match the input in terms of ending in a slash or not. |
| // Through all the transformations, these can get added or removed in various |
| // cases. |
| void MakeSlashEndingMatchInput(const std::string& input, std::string* output) { |
| if (EndsWithSlash(input)) { |
| if (!EndsWithSlash(*output)) // Preserve same slash type as input. |
| output->push_back(input[input.size() - 1]); |
| } else { |
| if (EndsWithSlash(*output)) |
| output->resize(output->size() - 1); |
| } |
| } |
| |
| // Returns true if the given value looks like a directory, otherwise we'll |
| // assume it's a file. |
| bool ValueLooksLikeDir(const std::string& value) { |
| if (value.empty()) |
| return true; |
| size_t value_size = value.size(); |
| |
| // Count the number of dots at the end of the string. |
| size_t num_dots = 0; |
| while (num_dots < value_size && value[value_size - num_dots - 1] == '.') |
| num_dots++; |
| |
| if (num_dots == value.size()) |
| return true; // String is all dots. |
| |
| if (IsSlash(value[value_size - num_dots - 1])) |
| return true; // String is a [back]slash followed by 0 or more dots. |
| |
| // Anything else. |
| return false; |
| } |
| |
| Value ConvertOnePath(const Scope* scope, |
| const FunctionCallNode* function, |
| const Value& value, |
| const SourceDir& from_dir, |
| const SourceDir& to_dir, |
| bool convert_to_system_absolute, |
| SeparatorConversion separator_conversion, |
| Err* err) { |
| Value result; // Ensure return value optimization. |
| |
| if (!value.VerifyTypeIs(Value::STRING, err)) |
| return result; |
| const std::string& string_value = value.string_value(); |
| |
| bool looks_like_dir = ValueLooksLikeDir(string_value); |
| |
| // System-absolute output special case. |
| if (convert_to_system_absolute) { |
| base::FilePath system_path; |
| if (looks_like_dir) { |
| system_path = scope->settings()->build_settings()->GetFullPath( |
| from_dir.ResolveRelativeDir(string_value)); |
| } else { |
| system_path = scope->settings()->build_settings()->GetFullPath( |
| from_dir.ResolveRelativeFile(string_value)); |
| } |
| result = Value(function, FilePathToUTF8(system_path)); |
| if (looks_like_dir) |
| MakeSlashEndingMatchInput(string_value, &result.string_value()); |
| ConvertPathToSystem(&result.string_value()); |
| return result; |
| } |
| |
| if (from_dir.is_system_absolute() || to_dir.is_system_absolute()) { |
| *err = Err(function, "System-absolute directories are not supported for " |
| "the source or dest dir for rebase_path. It would be nice to add this " |
| "if you're so inclined!"); |
| return result; |
| } |
| |
| result = Value(function, Value::STRING); |
| if (looks_like_dir) { |
| result.string_value() = RebaseSourceAbsolutePath( |
| from_dir.ResolveRelativeDir(string_value).value(), |
| to_dir); |
| MakeSlashEndingMatchInput(string_value, &result.string_value()); |
| } else { |
| result.string_value() = RebaseSourceAbsolutePath( |
| from_dir.ResolveRelativeFile(string_value).value(), |
| to_dir); |
| } |
| |
| ConvertSlashes(&result.string_value(), separator_conversion); |
| return result; |
| } |
| |
| } // namespace |
| |
| const char kRebasePath[] = "rebase_path"; |
| const char kRebasePath_Help[] = |
| "rebase_path: Rebase a file or directory to another location.\n" |
| "\n" |
| " converted = rebase_path(input,\n" |
| " new_base = \"\",\n" |
| " current_base = \".\",\n" |
| " path_separators = \"to_slash\")\n" |
| "\n" |
| " Takes a string argument representing a file name, or a list of such\n" |
| " strings and converts it/them to be relative to a different base\n" |
| " directory.\n" |
| "\n" |
| " When invoking the compiler or scripts, GN will automatically convert\n" |
| " sources and include directories to be relative to the build directory.\n" |
| " However, if you're passing files directly in the \"args\" array or\n" |
| " doing other manual manipulations where GN doesn't know something is\n" |
| " a file name, you will need to convert paths to be relative to what\n" |
| " your tool is expecting.\n" |
| "\n" |
| " The common case is to use this to convert paths relative to the\n" |
| " current directory to be relative to the build directory (which will\n" |
| " be the current directory when executing scripts).\n" |
| "\n" |
| "Arguments\n" |
| "\n" |
| " input\n" |
| " A string or list of strings representing file or directory names\n" |
| " These can be relative paths (\"foo/bar.txt\"), system absolute\n" |
| " paths (\"/foo/bar.txt\"), or source absolute paths\n" |
| " (\"//foo/bar.txt\").\n" |
| "\n" |
| " new_base\n" |
| " The directory to convert the paths to be relative to. This can be\n" |
| " an absolute path or a relative path (which will be treated\n" |
| " as being relative to the current BUILD-file's directory).\n" |
| "\n" |
| " As a special case, if new_base is the empty string (the default),\n" |
| " all paths will be converted to system-absolute native style paths\n" |
| " with system path separators. This is useful for invoking external\n" |
| " programs.\n" |
| "\n" |
| " current_base\n" |
| " Directory representing the base for relative paths in the input.\n" |
| " If this is not an absolute path, it will be treated as being\n" |
| " relative to the current build file. Use \".\" (the default) to\n" |
| " convert paths from the current BUILD-file's directory.\n" |
| "\n" |
| " path_separators\n" |
| " On Windows systems, indicates whether and how path separators\n" |
| " should be converted as part of the transformation. It can be one\n" |
| " of the following strings:\n" |
| " - \"to_slash\" Normalize all types of slashes to forward slashes.\n" |
| " This is the default if this argument is unspecified.\n" |
| " - \"to_system\" Convert to the system path separators\n" |
| " (backslashes on Windows).\n" |
| "\n" |
| " On Posix systems there are no path separator transformations\n" |
| " applied. If the new_base is empty (specifying absolute output)\n" |
| " this parameter should not be supplied since paths will always be\n" |
| " converted,\n" |
| "\n" |
| "Return value\n" |
| "\n" |
| " The return value will be the same type as the input value (either a\n" |
| " string or a list of strings). All relative and source-absolute file\n" |
| " names will be converted to be relative to the requested output\n" |
| " System-absolute paths will be unchanged.\n" |
| "\n" |
| "Example\n" |
| "\n" |
| " # Convert a file in the current directory to be relative to the build\n" |
| " # directory (the current dir when executing compilers and scripts).\n" |
| " foo = rebase_path(\"myfile.txt\", root_build_dir)\n" |
| " # might produce \"../../project/myfile.txt\".\n" |
| "\n" |
| " # Convert a file to be system absolute:\n" |
| " foo = rebase_path(\"myfile.txt\")\n" |
| " # Might produce \"D:\\source\\project\\myfile.txt\" on Windows or\n" |
| " # \"/home/you/source/project/myfile.txt\" on Linux.\n" |
| "\n" |
| " # Convert a file's path separators from forward slashes to system\n" |
| " # slashes.\n" |
| " foo = rebase_path(\"source/myfile.txt\", \".\", \".\", \"to_system\")\n" |
| "\n" |
| " # Typical usage for converting to the build directory for a script.\n" |
| " custom(\"myscript\") {\n" |
| " # Don't convert sources, GN will automatically convert these to be\n" |
| " # relative to the build directory when it contructs the command\n" |
| " # line for your script.\n" |
| " sources = [ \"foo.txt\", \"bar.txt\" ]\n" |
| "\n" |
| " # Extra file args passed manually need to be explicitly converted\n" |
| " # to be relative to the build directory:\n" |
| " args = [\n" |
| " \"--data\",\n" |
| " rebase_path(\"//mything/data/input.dat\", root_build_dir),\n" |
| " \"--rel\",\n" |
| " rebase_path(\"relative_path.txt\", root_build_dir)\n" |
| " ]\n" |
| " }\n"; |
| |
| Value RunRebasePath(Scope* scope, |
| const FunctionCallNode* function, |
| const std::vector<Value>& args, |
| Err* err) { |
| Value result; |
| |
| // Argument indices. |
| static const size_t kArgIndexInputs = 0; |
| static const size_t kArgIndexDest = 1; |
| static const size_t kArgIndexFrom = 2; |
| static const size_t kArgIndexPathConversion = 3; |
| |
| // Inputs. |
| if (args.size() < 1 || args.size() > 4) { |
| *err = Err(function->function(), "Wrong # of arguments for rebase_path."); |
| return result; |
| } |
| const Value& inputs = args[kArgIndexInputs]; |
| |
| // To path. |
| bool convert_to_system_absolute = true; |
| SourceDir to_dir; |
| const SourceDir& current_dir = scope->GetSourceDir(); |
| if (args.size() > kArgIndexDest) { |
| if (!args[kArgIndexDest].VerifyTypeIs(Value::STRING, err)) |
| return result; |
| if (!args[kArgIndexDest].string_value().empty()) { |
| to_dir = |
| current_dir.ResolveRelativeDir(args[kArgIndexDest].string_value()); |
| convert_to_system_absolute = false; |
| } |
| } |
| |
| // From path. |
| SourceDir from_dir; |
| if (args.size() > kArgIndexFrom) { |
| if (!args[kArgIndexFrom].VerifyTypeIs(Value::STRING, err)) |
| return result; |
| from_dir = |
| current_dir.ResolveRelativeDir(args[kArgIndexFrom].string_value()); |
| } else { |
| // Default to current directory if unspecified. |
| from_dir = current_dir; |
| } |
| |
| // Path conversion. |
| SeparatorConversion sep_conversion = SEP_TO_SLASH; |
| if (args.size() > kArgIndexPathConversion) { |
| if (convert_to_system_absolute) { |
| *err = Err(function, "Can't specify slash conversion.", |
| "You specified absolute system path output by using an empty string " |
| "for the destination directory on rebase_path(). In this case, you " |
| "can't specify slash conversion."); |
| return result; |
| } |
| |
| if (!args[kArgIndexPathConversion].VerifyTypeIs(Value::STRING, err)) |
| return result; |
| const std::string& sep_string = |
| args[kArgIndexPathConversion].string_value(); |
| if (sep_string == "to_slash") { |
| sep_conversion = SEP_TO_SLASH; |
| } else if (sep_string == "to_system") { |
| sep_conversion = SEP_TO_SYSTEM; |
| } else { |
| *err = Err(args[kArgIndexPathConversion], |
| "Invalid path separator conversion mode.", |
| "I was expecting \"to_slash\" or \"to_system\" and\n" |
| "you gave me \"" + args[kArgIndexPathConversion].string_value() + |
| "\"."); |
| return result; |
| } |
| } |
| |
| if (inputs.type() == Value::STRING) { |
| return ConvertOnePath(scope, function, inputs, |
| from_dir, to_dir, convert_to_system_absolute, |
| sep_conversion, err); |
| |
| } else if (inputs.type() == Value::LIST) { |
| result = Value(function, Value::LIST); |
| result.list_value().reserve(inputs.list_value().size()); |
| |
| for (size_t i = 0; i < inputs.list_value().size(); i++) { |
| result.list_value().push_back( |
| ConvertOnePath(scope, function, inputs.list_value()[i], |
| from_dir, to_dir, convert_to_system_absolute, |
| sep_conversion, err)); |
| if (err->has_error()) { |
| result = Value(); |
| return result; |
| } |
| } |
| return result; |
| } |
| |
| *err = Err(function->function(), |
| "rebase_path requires a list or a string."); |
| return result; |
| } |
| |
| } // namespace functions |
