C++ FileSpec::GetDirectory方法代码示例

bool
FileSpec::Equal (const FileSpec& a, const FileSpec& b, bool full)
{
    if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty()))
        return a.m_filename == b.m_filename;
    else
        return a == b;
}

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

    bool FileSpecMatchesAsBaseOrFull(const FileSpec &left,
                                     const FileSpec &right) const {
        // If the filenames don't match, the paths can't be equal
        if (!left.FileEquals(right))
            return false;
        // If BOTH have a directory, also compare the directories.
        if (left.GetDirectory() && right.GetDirectory())
            return left.DirectoryEquals(right);

        // If one has a directory but not the other, they match.
        return true;
    }

Error
Platform::ResolveExecutable (const FileSpec &exe_file,
                             const ArchSpec &exe_arch,
                             lldb::ModuleSP &exe_module_sp)
{
    Error error;
    if (exe_file.Exists())
    {
        if (exe_arch.IsValid())
        {
            error = ModuleList::GetSharedModule (exe_file, 
                                                 exe_arch, 
                                                 NULL,
                                                 NULL, 
                                                 0, 
                                                 exe_module_sp, 
                                                 NULL, 
                                                 NULL);
        }
        else
        {
            // No valid architecture was specified, ask the platform for
            // the architectures that we should be using (in the correct order)
            // and see if we can find a match that way
            ArchSpec platform_arch;
            for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, platform_arch); ++idx)
            {
                error = ModuleList::GetSharedModule (exe_file, 
                                                     platform_arch, 
                                                     NULL,
                                                     NULL, 
                                                     0, 
                                                     exe_module_sp, 
                                                     NULL, 
                                                     NULL);
                // Did we find an executable using one of the 
                if (error.Success() && exe_module_sp)
                    break;
            }
        }
    }
    else
    {
        error.SetErrorStringWithFormat ("'%s%s%s' does not exist",
                                        exe_file.GetDirectory().AsCString(""),
                                        exe_file.GetDirectory() ? "/" : "",
                                        exe_file.GetFilename().AsCString(""));
    }
    return error;
}

TargetSP
TargetList::FindTargetWithExecutableAndArchitecture
(
    const FileSpec &exe_file_spec,
    const ArchSpec *exe_arch_ptr
) const
{
    Mutex::Locker locker (m_target_list_mutex);
    TargetSP target_sp;
    bool full_match = (bool)exe_file_spec.GetDirectory();

    collection::const_iterator pos, end = m_target_list.end();
    for (pos = m_target_list.begin(); pos != end; ++pos)
    {
        Module *exe_module = (*pos)->GetExecutableModulePointer();

        if (exe_module)
        {
            if (FileSpec::Equal (exe_file_spec, exe_module->GetFileSpec(), full_match))
            {
                if (exe_arch_ptr)
                {
                    if (!exe_arch_ptr->IsCompatibleMatch(exe_module->GetArchitecture()))
                        continue;
                }
                target_sp = *pos;
                break;
            }
        }
    }
    return target_sp;
}

bool
HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec)
{
    FileSpec temp_file("/opt/local/include/lldb", false);
    file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
    return true;
}

static Error save_socket_id_to_file(const std::string &socket_id,
                                    const FileSpec &file_spec) {
  FileSpec temp_file_spec(file_spec.GetDirectory().AsCString(), false);
  auto error = FileSystem::MakeDirectory(temp_file_spec,
                                         eFilePermissionsDirectoryDefault);
  if (error.Fail())
    return Error("Failed to create directory %s: %s",
                 temp_file_spec.GetCString(), error.AsCString());

  llvm::SmallString<PATH_MAX> temp_file_path;
  temp_file_spec.AppendPathComponent("port-file.%%%%%%");
  auto err_code = llvm::sys::fs::createUniqueFile(temp_file_spec.GetCString(),
                                                  temp_file_path);
  if (err_code)
    return Error("Failed to create temp file: %s", err_code.message().c_str());

  llvm::FileRemover tmp_file_remover(temp_file_path.c_str());

  {
    std::ofstream temp_file(temp_file_path.c_str(), std::ios::out);
    if (!temp_file.is_open())
      return Error("Failed to open temp file %s", temp_file_path.c_str());
    temp_file << socket_id;
  }

  err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath());
  if (err_code)
    return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(),
                 file_spec.GetPath().c_str(), err_code.message().c_str());

  tmp_file_remover.releaseFile();
  return Error();
}

//------------------------------------------------------------------
// Find the index of the file in the file spec list that matches
// "file_spec" starting "start_idx" entries into the file spec list.
//
// Returns the valid index of the file that matches "file_spec" if
// it is found, else UINT32_MAX is returned.
//------------------------------------------------------------------
uint32_t
FileSpecList::FindFileIndex (uint32_t start_idx, const FileSpec &file_spec, bool full) const
{
    const uint32_t num_files = m_files.size();
    uint32_t idx;

    // When looking for files, we will compare only the filename if the
    // FILE_SPEC argument is empty
    bool compare_filename_only = file_spec.GetDirectory().IsEmpty();

    for (idx = start_idx; idx < num_files; ++idx)
    {
        if (compare_filename_only)
        {
            if (m_files[idx].GetFilename() == file_spec.GetFilename())
                return idx;
        }
        else
        {
            if (FileSpec::Equal (m_files[idx], file_spec, full))
                return idx;
        }
    }

    // We didn't find the file, return an invalid index
    return UINT32_MAX;
}

bool
HostInfoLinux::ComputeSystemPluginsDirectory(FileSpec &file_spec)
{
    FileSpec temp_file("/usr/lib/lldb", true);
    file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
    return true;
}

bool
HostInfoLinux::ComputeUserPluginsDirectory(FileSpec &file_spec)
{
    // XDG Base Directory Specification
    // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
    // If XDG_DATA_HOME exists, use that, otherwise use ~/.local/share/lldb.
    const char *xdg_data_home = getenv("XDG_DATA_HOME");
    if (xdg_data_home && xdg_data_home[0])
    {
        std::string user_plugin_dir(xdg_data_home);
        user_plugin_dir += "/lldb";
        file_spec.GetDirectory().SetCString(user_plugin_dir.c_str());
    }
    else
        file_spec.GetDirectory().SetCString("~/.local/share/lldb");
    return true;
}

Error
ModuleCache::CreateHostSysRootModuleSymLink (const FileSpec &sysroot_module_path_spec, const FileSpec &module_file_path)
{
    const auto error = MakeDirectory (FileSpec (sysroot_module_path_spec.GetDirectory ().AsCString (), false));
    if (error.Fail ())
        return error;

    return FileSystem::Symlink (sysroot_module_path_spec.GetPath ().c_str (),
                                module_file_path.GetPath ().c_str ());
}

bool
HostInfoBase::ComputeSharedLibraryDirectory(FileSpec &file_spec)
{
    // To get paths related to LLDB we get the path to the executable that
    // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB",
    // on linux this is assumed to be the "lldb" main executable. If LLDB on
    // linux is actually in a shared library (liblldb.so) then this function will
    // need to be modified to "do the right thing".

    FileSpec lldb_file_spec(
        Host::GetModuleFileSpecForHostAddress(reinterpret_cast<void *>(reinterpret_cast<intptr_t>(HostInfoBase::GetLLDBPath))));
    
    // This is necessary because when running the testsuite the shlib might be a symbolic link inside the Python resource dir.
    FileSystem::ResolveSymbolicLink(lldb_file_spec, lldb_file_spec);
    
    // Remove the filename so that this FileSpec only represents the directory.
    file_spec.GetDirectory() = lldb_file_spec.GetDirectory();

    return (bool)file_spec.GetDirectory();
}

uint32_t
Module::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
{
    Mutex::Locker locker (m_mutex);
    Timer scoped_timer(__PRETTY_FUNCTION__,
                       "Module::ResolveSymbolContextForFilePath (%s%s%s:%u, check_inlines = %s, resolve_scope = 0x%8.8x)",
                       file_spec.GetDirectory().AsCString(""),
                       file_spec.GetDirectory() ? "/" : "",
                       file_spec.GetFilename().AsCString(""),
                       line,
                       check_inlines ? "yes" : "no",
                       resolve_scope);

    const uint32_t initial_count = sc_list.GetSize();

    SymbolVendor *symbols = GetSymbolVendor  ();
    if (symbols)
        symbols->ResolveSymbolContext (file_spec, line, check_inlines, resolve_scope, sc_list);

    return sc_list.GetSize() - initial_count;
}

ModuleSP
Target::GetSharedModule
(
    const FileSpec& file_spec,
    const ArchSpec& arch,
    const lldb_private::UUID *uuid_ptr,
    const ConstString *object_name,
    off_t object_offset,
    Error *error_ptr
)
{
    // Don't pass in the UUID so we can tell if we have a stale value in our list
    ModuleSP old_module_sp; // This will get filled in if we have a new version of the library
    bool did_create_module = false;
    ModuleSP module_sp;

    // If there are image search path entries, try to use them first to acquire a suitable image.

    Error error;

    if (m_image_search_paths.GetSize())
    {
        FileSpec transformed_spec;
        if (m_image_search_paths.RemapPath (file_spec.GetDirectory(), transformed_spec.GetDirectory()))
        {
            transformed_spec.GetFilename() = file_spec.GetFilename();
            error = ModuleList::GetSharedModule (transformed_spec, arch, uuid_ptr, object_name, object_offset, module_sp, &old_module_sp, &did_create_module);
        }
    }

    // If a module hasn't been found yet, use the unmodified path.

    if (!module_sp)
    {
        error = (ModuleList::GetSharedModule (file_spec, arch, uuid_ptr, object_name, object_offset, module_sp, &old_module_sp, &did_create_module));
    }

    if (module_sp)
    {
        m_images.Append (module_sp);
        if (did_create_module)
        {
            if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32)
                ModuleUpdated(old_module_sp, module_sp);
            else
                ModuleAdded(module_sp);
        }
    }
    if (error_ptr)
        *error_ptr = error;
    return module_sp;
}

bool
HostInfoWindows::ComputePythonDirectory(FileSpec &file_spec)
{
    FileSpec lldb_file_spec;
    if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
        return false;
    llvm::SmallString<64> path(lldb_file_spec.GetDirectory().AsCString());
    llvm::sys::path::remove_filename(path);
    llvm::sys::path::append(path, "lib", "site-packages");
    std::replace(path.begin(), path.end(), '\\', '/');
    file_spec.GetDirectory().SetString(path.c_str());
    return true;
}