Rename `FileSpec::IsRelativeToCurrentWorkingDirectory` to `IsRelative`.

[chaoren]

Summary

IsRelativeToCurrentWorkingDirectory was misleading, because relative paths
are sometimes appended to other directories, not just the cwd. Plus, the new
name is shorter. Also added IsAbsolute for completeness.

[chaoren]

If no one has any problems with this rename, I'm going to commit it later today.

[ovyalov]

LGTM

lldb/trunk/include/lldb/Host/FileSpec.h

public:
     /// @return
     ///     \b true if the filespec represents an implementation source
     ///     file, \b false otherwise.
     //------------------------------------------------------------------
     bool
     IsSourceImplementationFile () const;
 
     //------------------------------------------------------------------
-    /// Returns true if the filespec represents path that is relative
-    /// path to the current working directory.
+    /// Returns true if the filespec represents a relative path.
     ///
     /// @return
-    ///     \b true if the filespec represents a current working
-    ///     directory relative path, \b false otherwise.
+    ///     \b true if the filespec represents a relative path,
+    ///     \b false otherwise.
     //------------------------------------------------------------------
     bool
-    IsRelativeToCurrentWorkingDirectory () const;
-    
+    IsRelative() const;
+
+    //------------------------------------------------------------------
+    /// Returns true if the filespec represents an absolute path.
+    ///
+    /// @return
+    ///     \b true if the filespec represents an absolute path,
+    ///     \b false otherwise.
+    //------------------------------------------------------------------
+    bool
+    IsAbsolute() const;
     TimeValue
     GetModificationTime () const;
 
     //------------------------------------------------------------------
     /// Extract the full path to the file.
     ///
     /// Extract the directory and path into a fixed buffer. This is
     /// needed as the directory and path are stored in separate string

lldb/trunk/source/Host/common/FileSpec.cpp

FileSpec::IsSourceImplementationFile () const
     {
         static RegularExpression g_source_file_regex ("^([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|[cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO][rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])$");
         return g_source_file_regex.Execute (extension.GetCString());
     }
     return false;
 }
 
 bool
-FileSpec::IsRelativeToCurrentWorkingDirectory () const
+FileSpec::IsRelative() const
 {
     const char *dir = m_directory.GetCString();
     llvm::StringRef directory(dir ? dir : "");
 
     if (directory.size() > 0)
     {
         if (PathSyntaxIsPosix(m_syntax))
         {
FileSpec::IsRelative() const
     }
     else if (m_filename)
     {
         // No directory, just a basename, return true
         return true;
     }
     return false;
 }
+
+bool
+FileSpec::IsAbsolute() const
+{
+    return !FileSpec::IsRelative();
+}

lldb/trunk/source/Host/linux/HostInfoLinux.cpp

HostInfoLinux::GetProgramFileSpec()
 
     return g_program_filespec;
 }
 
 bool
 HostInfoLinux::ComputeSupportExeDirectory(FileSpec &file_spec)
 {
     if (HostInfoPosix::ComputeSupportExeDirectory(file_spec) &&
-            !file_spec.IsRelativeToCurrentWorkingDirectory() &&
+            file_spec.IsAbsolute() &&
             file_spec.Exists())
         return true;
     file_spec.GetDirectory() = GetProgramFileSpec().GetDirectory();
     return !file_spec.GetDirectory().IsEmpty();
 }
 
 bool
 HostInfoLinux::ComputeSystemPluginsDirectory(FileSpec &file_spec)

lldb/trunk/source/Plugins/Platform/Android/PlatformAndroid.cpp

 Error
 PlatformAndroid::GetFile (const FileSpec& source,
                           const FileSpec& destination)
 {
     if (IsHost() || !m_remote_platform_sp)
         return PlatformLinux::GetFile(source, destination);
 
     FileSpec source_spec (source.GetPath (false), false, FileSpec::ePathSyntaxPosix);
-    if (source_spec.IsRelativeToCurrentWorkingDirectory ())
+    if (source_spec.IsRelative())
         source_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (source_spec.GetCString (false));
 
     AdbClient adb (m_device_id);
     return adb.PullFile (source_spec, destination);
 }
 
 Error
 PlatformAndroid::PutFile (const FileSpec& source,
                           const FileSpec& destination,
                           uint32_t uid,
                           uint32_t gid)
 {
     if (IsHost() || !m_remote_platform_sp)
         return PlatformLinux::PutFile (source, destination, uid, gid);
 
     FileSpec destination_spec (destination.GetPath (false), false, FileSpec::ePathSyntaxPosix);
-    if (destination_spec.IsRelativeToCurrentWorkingDirectory ())
+    if (destination_spec.IsRelative())
         destination_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (destination_spec.GetCString (false));
 
     AdbClient adb (m_device_id);
     // TODO: Set correct uid and gid on remote file.
     return adb.PushFile(source, destination_spec);
 }
 
 const char *

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

DWARFDebugLine::ParseSupportFiles (const lldb::ModuleSP &module_sp,
     {
         FileSpec file_spec{debug_line_data.GetCStr(&offset), false};
         if (file_spec)
         {
             uint32_t dir_idx = debug_line_data.GetULEB128(&offset);
             debug_line_data.Skip_LEB128(&offset); // Skip mod_time
             debug_line_data.Skip_LEB128(&offset); // Skip length
 
-            if (file_spec.IsRelativeToCurrentWorkingDirectory())
+            if (file_spec.IsRelative())
             {
                 if (0 < dir_idx && dir_idx < include_directories.size())
                 {
                     const FileSpec &dir = include_directories[dir_idx];
                     file_spec.PrependPathComponent(dir);
                 }
-                if (file_spec.IsRelativeToCurrentWorkingDirectory())
+                if (file_spec.IsRelative())
                     file_spec.PrependPathComponent(cu_comp_dir);
             }
             std::string remapped_file;
             if (module_sp->RemapSourceFile(file_spec.GetCString(), remapped_file))
                 file_spec.SetFile(remapped_file, false);
             support_files.Append(file_spec);
         }
     }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (dwarf_cu)
                     const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
                     if (cu_die)
                     {
                         FileSpec cu_file_spec{cu_die->GetName(this, dwarf_cu), false};
                         if (cu_file_spec)
                         {
                             // If we have a full path to the compile unit, we don't need to resolve
                             // the file.  This can be expensive e.g. when the source files are NFS mounted.
-                            if (cu_file_spec.IsRelativeToCurrentWorkingDirectory())
+                            if (cu_file_spec.IsRelative())
                             {
                                 // DWARF2/3 suggests the form hostname:pathname for compilation directory.
                                 // Remove the host part if present.
                                 const char *cu_comp_dir{cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, nullptr)};
                                 cu_file_spec.PrependPathComponent(removeHostnameFromPathname(cu_comp_dir));
                             }
 
                             std::string remapped_file;

lldb/trunk/source/Target/ProcessLaunchInfo.cpp

if (GetFlags().Test (eLaunchFlagLaunchInShell))
 
             StreamString shell_command;
             if (will_debug)
             {
                 // Add a modified PATH environment variable in case argv[0]
                 // is a relative path.
                 const char *argv0 = argv[0];
                 FileSpec arg_spec(argv0, false);
-                if (arg_spec.IsRelativeToCurrentWorkingDirectory())
+                if (arg_spec.IsRelative())
                 {
                     // We have a relative path to our executable which may not work if
                     // we just try to run "a.out" (without it being converted to "./a.out")
                     FileSpec working_dir = GetWorkingDirectory();
                     // Be sure to put quotes around PATH's value in case any paths have spaces...
                     std::string new_path("PATH=\"");
                     const size_t empty_path_len = new_path.size();
 

lldb/trunk/source/Target/TargetList.cpp

TargetList::CreateTargetInternal (Debugger &debugger,
     bool user_exe_path_is_bundle = false;
     char resolved_bundle_exe_path[PATH_MAX];
     resolved_bundle_exe_path[0] = '\0';
     if (file)
     {
         if (file.GetFileType() == FileSpec::eFileTypeDirectory)
             user_exe_path_is_bundle = true;
 
-        if (file.IsRelativeToCurrentWorkingDirectory() && user_exe_path)
+        if (file.IsRelative() && user_exe_path)
         {
             // Ignore paths that start with "./" and "../"
             if (!((user_exe_path[0] == '.' && user_exe_path[1] == '/') ||
                   (user_exe_path[0] == '.' && user_exe_path[1] == '.' && user_exe_path[2] == '/')))
             {
                 char cwd[PATH_MAX];
                 if (getcwd (cwd, sizeof(cwd)))
                 {