forked from OSchip/llvm-project
225 lines
6.6 KiB
C++
225 lines
6.6 KiB
C++
//===-- FileSpecList.cpp ----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/FileSpecList.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <algorithm>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Stream.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace std;
|
|
|
|
FileSpecList::FileSpecList() :
|
|
m_files()
|
|
{
|
|
}
|
|
|
|
FileSpecList::FileSpecList(const FileSpecList& rhs) = default;
|
|
|
|
FileSpecList::~FileSpecList() = default;
|
|
|
|
//------------------------------------------------------------------
|
|
// Assignment operator
|
|
//------------------------------------------------------------------
|
|
const FileSpecList&
|
|
FileSpecList::operator= (const FileSpecList& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
m_files = rhs.m_files;
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Append the "file_spec" to the end of the file spec list.
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpecList::Append(const FileSpec &file_spec)
|
|
{
|
|
m_files.push_back(file_spec);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Only append the "file_spec" if this list doesn't already contain
|
|
// it.
|
|
//
|
|
// Returns true if "file_spec" was added, false if this list already
|
|
// contained a copy of "file_spec".
|
|
//------------------------------------------------------------------
|
|
bool
|
|
FileSpecList::AppendIfUnique(const FileSpec &file_spec)
|
|
{
|
|
collection::iterator pos, end = m_files.end();
|
|
if (find(m_files.begin(), end, file_spec) == end)
|
|
{
|
|
m_files.push_back(file_spec);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Clears the file list.
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpecList::Clear()
|
|
{
|
|
m_files.clear();
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Dumps the file list to the supplied stream pointer "s".
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpecList::Dump(Stream *s, const char *separator_cstr) const
|
|
{
|
|
collection::const_iterator pos, end = m_files.end();
|
|
for (pos = m_files.begin(); pos != end; ++pos)
|
|
{
|
|
pos->Dump(s);
|
|
if (separator_cstr && ((pos + 1) != end))
|
|
s->PutCString(separator_cstr);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// 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 std::numeric_limits<uint32_t>::max() is returned.
|
|
//------------------------------------------------------------------
|
|
size_t
|
|
FileSpecList::FindFileIndex (size_t start_idx, const FileSpec &file_spec, bool full, bool remove_dots) const
|
|
{
|
|
const size_t num_files = m_files.size();
|
|
|
|
// 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 (size_t idx = start_idx; idx < num_files; ++idx)
|
|
{
|
|
if (compare_filename_only)
|
|
{
|
|
if (ConstString::Equals(m_files[idx].GetFilename(), file_spec.GetFilename(),
|
|
file_spec.IsCaseSensitive() || m_files[idx].IsCaseSensitive()))
|
|
return idx;
|
|
}
|
|
else
|
|
{
|
|
if (FileSpec::Equal (m_files[idx], file_spec, full, remove_dots))
|
|
return idx;
|
|
}
|
|
}
|
|
|
|
// We didn't find the file, return an invalid index
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Returns the FileSpec object at index "idx". If "idx" is out of
|
|
// range, then an empty FileSpec object will be returned.
|
|
//------------------------------------------------------------------
|
|
const FileSpec &
|
|
FileSpecList::GetFileSpecAtIndex(size_t idx) const
|
|
{
|
|
if (idx < m_files.size())
|
|
return m_files[idx];
|
|
static FileSpec g_empty_file_spec;
|
|
return g_empty_file_spec;
|
|
}
|
|
|
|
const FileSpec *
|
|
FileSpecList::GetFileSpecPointerAtIndex(size_t idx) const
|
|
{
|
|
if (idx < m_files.size())
|
|
return &m_files[idx];
|
|
return nullptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Return the size in bytes that this object takes in memory. This
|
|
// returns the size in bytes of this object's member variables and
|
|
// any FileSpec objects its member variables contain, the result
|
|
// doesn't not include the string values for the directories any
|
|
// filenames as those are in shared string pools.
|
|
//------------------------------------------------------------------
|
|
size_t
|
|
FileSpecList::MemorySize () const
|
|
{
|
|
size_t mem_size = sizeof(FileSpecList);
|
|
collection::const_iterator pos, end = m_files.end();
|
|
for (pos = m_files.begin(); pos != end; ++pos)
|
|
{
|
|
mem_size += pos->MemorySize();
|
|
}
|
|
|
|
return mem_size;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Return the number of files in the file spec list.
|
|
//------------------------------------------------------------------
|
|
size_t
|
|
FileSpecList::GetSize() const
|
|
{
|
|
return m_files.size();
|
|
}
|
|
|
|
size_t
|
|
FileSpecList::GetFilesMatchingPartialPath (const char *path, bool dir_okay, FileSpecList &matches)
|
|
{
|
|
#if 0 // FIXME: Just sketching...
|
|
matches.Clear();
|
|
FileSpec path_spec = FileSpec (path);
|
|
if (path_spec.Exists ())
|
|
{
|
|
FileSpec::FileType type = path_spec.GetFileType();
|
|
if (type == FileSpec::eFileTypeSymbolicLink)
|
|
// Shouldn't there be a Resolve on a file spec that real-path's it?
|
|
{
|
|
}
|
|
|
|
if (type == FileSpec::eFileTypeRegular
|
|
|| (type == FileSpec::eFileTypeDirectory && dir_okay))
|
|
{
|
|
matches.Append (path_spec);
|
|
return 1;
|
|
}
|
|
else if (type == FileSpec::eFileTypeDirectory)
|
|
{
|
|
// Fill the match list with all the files in the directory:
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ConstString dir_name = path_spec.GetDirectory();
|
|
ConstString file_name = GetFilename();
|
|
if (dir_name == nullptr)
|
|
{
|
|
// Match files in the CWD.
|
|
}
|
|
else
|
|
{
|
|
// Match files in the given directory:
|
|
}
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|