intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-14 11:57:39 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
ca92aed5dc6301ff1bf642fdc44d8b344106e98a
llvm/lldb/source/Interpreter/OptionValueArray.cpp
Jason Molenda 62e0681afb Add -Wimplicit-fallthrough command line option to clang in 
the xcode project file to catch switch statements that have a
case that falls through unintentionally.

Define LLVM_FALLTHROUGH to indicate instances where a case has code
and intends to fall through.  This should be in llvm/Support/Compiler.h;
Peter Collingbourne originally checked in there (r237766), then
reverted (r237941) because he didn't have time to mark up all the
'case' statements that were intended to fall through.  I put together
a patch to get this back in llvm http://reviews.llvm.org/D17063 but
it hasn't been approved in the past week.  I added a new
lldb-private-defines.h to hold the definition for now.

Every place in lldb where there is a comment that the fall-through
is intentional, I added LLVM_FALLTHROUGH to silence the warning.
I haven't tried to identify whether the fallthrough is a bug or
not in the other places.

I haven't tried to add this to the cmake option build flags.
This warning will only work for clang.

This build cleanly (with some new warnings) on macosx with clang
under xcodebuild, but if this causes problems for people on other
configurations, I'll back it out.

llvm-svn: 260930
2016-02-16 04:14:33 +00:00

360 lines
12 KiB
C++
Raw Blame History

//===-- OptionValueArray.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/Interpreter/OptionValueArray.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Stream.h"
#include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/Args.h"
using namespace lldb;
using namespace lldb_private;
void
OptionValueArray::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
{
const Type array_element_type = ConvertTypeMaskToType (m_type_mask);
if (dump_mask & eDumpOptionType)
{
if ((GetType() == eTypeArray) && (m_type_mask != eTypeInvalid))
strm.Printf ("(%s of %ss)", GetTypeAsCString(), GetBuiltinTypeAsCString(array_element_type));
else
strm.Printf ("(%s)", GetTypeAsCString());
}
if (dump_mask & eDumpOptionValue)
{
if (dump_mask & eDumpOptionType)
strm.Printf (" =%s", (m_values.size() > 0) ? "\n" : "");
strm.IndentMore();
const uint32_t size = m_values.size();
for (uint32_t i = 0; i<size; ++i)
{
strm.Indent();
strm.Printf("[%u]: ", i);
const uint32_t extra_dump_options = m_raw_value_dump ? eDumpOptionRaw : 0;
switch (array_element_type)
{
default:
case eTypeArray:
case eTypeDictionary:
case eTypeProperties:
case eTypeFileSpecList:
case eTypePathMap:
m_values[i]->DumpValue(exe_ctx, strm, dump_mask | extra_dump_options);
break;
case eTypeBoolean:
case eTypeChar:
case eTypeEnum:
case eTypeFileSpec:
case eTypeFormat:
case eTypeSInt64:
case eTypeString:
case eTypeUInt64:
case eTypeUUID:
// No need to show the type for dictionaries of simple items
m_values[i]->DumpValue(exe_ctx, strm, (dump_mask & (~eDumpOptionType)) | extra_dump_options);
break;
}
if (i < (size - 1))
strm.EOL();
}
strm.IndentLess();
}
}
Error
OptionValueArray::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
{
Args args(value.str().c_str());
Error error = SetArgs (args, op);
if (error.Success())
NotifyValueChanged();
return error;
}
lldb::OptionValueSP
OptionValueArray::GetSubValue (const ExecutionContext *exe_ctx,
const char *name,
bool will_modify,
Error &error) const
{
if (name && name[0] == '[')
{
const char *end_bracket = strchr (name+1, ']');
if (end_bracket)
{
const char *sub_value = nullptr;
if (end_bracket[1])
sub_value = end_bracket + 1;
std::string index_str (name+1, end_bracket);
const size_t array_count = m_values.size();
int32_t idx = StringConvert::ToSInt32(index_str.c_str(), INT32_MAX, 0, nullptr);
if (idx != INT32_MAX)
{
;
uint32_t new_idx = UINT32_MAX;
if (idx < 0)
{
// Access from the end of the array if the index is negative
new_idx = array_count - idx;
}
else
{
// Just a standard index
new_idx = idx;
}
if (new_idx < array_count)
{
if (m_values[new_idx])
{
if (sub_value)
return m_values[new_idx]->GetSubValue (exe_ctx, sub_value, will_modify, error);
else
return m_values[new_idx];
}
}
else
{
if (array_count == 0)
error.SetErrorStringWithFormat("index %i is not valid for an empty array", idx);
else if (idx > 0)
error.SetErrorStringWithFormat("index %i out of range, valid values are 0 through %" PRIu64, idx, (uint64_t)(array_count - 1));
else
error.SetErrorStringWithFormat("negative index %i out of range, valid values are -1 through -%" PRIu64, idx, (uint64_t)array_count);
}
}
}
}
else
{
error.SetErrorStringWithFormat("invalid value path '%s', %s values only support '[<index>]' subvalues where <index> is a positive or negative array index", name, GetTypeAsCString());
}
return OptionValueSP();
}
size_t
OptionValueArray::GetArgs (Args &args) const
{
const uint32_t size = m_values.size();
std::vector<const char *> argv;
for (uint32_t i = 0; i<size; ++i)
{
const char *string_value = m_values[i]->GetStringValue ();
if (string_value)
argv.push_back(string_value);
}
if (argv.empty())
args.Clear();
else
args.SetArguments(argv.size(), &argv[0]);
return args.GetArgumentCount();
}
Error
OptionValueArray::SetArgs (const Args &args, VarSetOperationType op)
{
Error error;
const size_t argc = args.GetArgumentCount();
switch (op)
{
case eVarSetOperationInvalid:
error.SetErrorString("unsupported operation");
break;
case eVarSetOperationInsertBefore:
case eVarSetOperationInsertAfter:
if (argc > 1)
{
uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
const uint32_t count = GetSize();
if (idx > count)
{
error.SetErrorStringWithFormat("invalid insert array index %u, index must be 0 through %u", idx, count);
}
else
{
if (op == eVarSetOperationInsertAfter)
++idx;
for (size_t i=1; i<argc; ++i, ++idx)
{
lldb::OptionValueSP value_sp (CreateValueFromCStringForTypeMask (args.GetArgumentAtIndex(i),
m_type_mask,
error));
if (value_sp)
{
if (error.Fail())
return error;
if (idx >= m_values.size())
m_values.push_back(value_sp);
else
m_values.insert(m_values.begin() + idx, value_sp);
}
else
{
error.SetErrorString("array of complex types must subclass OptionValueArray");
return error;
}
}
}
}
else
{
error.SetErrorString("insert operation takes an array index followed by one or more values");
}
break;
case eVarSetOperationRemove:
if (argc > 0)
{
const uint32_t size = m_values.size();
std::vector<int> remove_indexes;
bool all_indexes_valid = true;
size_t i;
for (i=0; i<argc; ++i)
{
const size_t idx =
StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
if (idx >= size)
{
all_indexes_valid = false;
break;
}
else
remove_indexes.push_back(idx);
}
if (all_indexes_valid)
{
size_t num_remove_indexes = remove_indexes.size();
if (num_remove_indexes)
{
// Sort and then erase in reverse so indexes are always valid
if (num_remove_indexes > 1)
{
std::sort(remove_indexes.begin(), remove_indexes.end());
for (std::vector<int>::const_reverse_iterator pos = remove_indexes.rbegin(), end = remove_indexes.rend(); pos != end; ++pos)
{
m_values.erase(m_values.begin() + *pos);
}
}
else
{
// Only one index
m_values.erase(m_values.begin() + remove_indexes.front());
}
}
}
else
{
error.SetErrorStringWithFormat("invalid array index '%s', aborting remove operation", args.GetArgumentAtIndex(i));
}
}
else
{
error.SetErrorString("remove operation takes one or more array indices");
}
break;
case eVarSetOperationClear:
Clear ();
break;
case eVarSetOperationReplace:
if (argc > 1)
{
uint32_t idx = StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
const uint32_t count = GetSize();
if (idx > count)
{
error.SetErrorStringWithFormat("invalid replace array index %u, index must be 0 through %u", idx, count);
}
else
{
for (size_t i=1; i<argc; ++i, ++idx)
{
lldb::OptionValueSP value_sp (CreateValueFromCStringForTypeMask (args.GetArgumentAtIndex(i),
m_type_mask,
error));
if (value_sp)
{
if (error.Fail())
return error;
if (idx < count)
m_values[idx] = value_sp;
else
m_values.push_back(value_sp);
}
else
{
error.SetErrorString("array of complex types must subclass OptionValueArray");
return error;
}
}
}
}
else
{
error.SetErrorString("replace operation takes an array index followed by one or more values");
}
break;
case eVarSetOperationAssign:
m_values.clear();
// Fall through to append case
LLVM_FALLTHROUGH;
case eVarSetOperationAppend:
for (size_t i=0; i<argc; ++i)
{
lldb::OptionValueSP value_sp (CreateValueFromCStringForTypeMask (args.GetArgumentAtIndex(i),
m_type_mask,
error));
if (value_sp)
{
if (error.Fail())
return error;
m_value_was_set = true;
AppendValue(value_sp);
}
else
{
error.SetErrorString("array of complex types must subclass OptionValueArray");
}
}
break;
}
return error;
}
lldb::OptionValueSP
OptionValueArray::DeepCopy () const
{
OptionValueArray *copied_array = new OptionValueArray (m_type_mask, m_raw_value_dump);
lldb::OptionValueSP copied_value_sp(copied_array);
*static_cast<OptionValue *>(copied_array) = *this;
copied_array->m_callback = m_callback;
const uint32_t size = m_values.size();
for (uint32_t i = 0; i<size; ++i)
{
copied_array->AppendValue (m_values[i]->DeepCopy());
}
return copied_value_sp;
}
Reference in New Issue View Git Blame Copy Permalink