void
CommandObject::GetArgumentHelp (Stream &str, CommandArgumentType arg_type, CommandInterpreter &interpreter)
{
const ArgumentTableEntry* table = CommandObject::GetArgumentTable();
ArgumentTableEntry *entry = (ArgumentTableEntry *) &(table[arg_type]);
// The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up...
if (entry->arg_type != arg_type)
entry = CommandObject::FindArgumentDataByType (arg_type);
if (!entry)
return;
StreamString name_str;
name_str.Printf ("<%s>", entry->arg_name);
if (entry->help_function)
{
const char* help_text = entry->help_function();
if (!entry->help_function.self_formatting)
{
interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", help_text,
name_str.GetSize());
}
else
{
interpreter.OutputHelpText(str, name_str.GetData(), "--", help_text,
name_str.GetSize());
}
}
else
interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", entry->help_text, name_str.GetSize());
}
bool
FilesType::List( CommandInterpreter& inInterpreter )
{
string dir = inInterpreter.GetOptionalToken(),
wildcard = inInterpreter.GetOptionalToken();
return DirectoryType::ListSelection( inInterpreter, dir, wildcard, &FileUtils::IsFile );
}
bool
DirectoryType::Exists( CommandInterpreter& inInterpreter )
{
bool result = FileUtils::IsDirectory( inInterpreter.GetToken() );
inInterpreter.Out() << ( result ? "true" : "false" );
return true;
}
bool
StateType::List( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
inInterpreter.Out() << GetState( inInterpreter );
return true;
}
bool
StateType::Exists( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
bool exists = inInterpreter.StateMachine().States().Exists( inInterpreter.GetToken() );
inInterpreter.Out() << ( exists ? "true" : "false" );
return true;
}
bool
StateType::Get( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
const State& state = GetState( inInterpreter ); // GetState() tests for existence of the state.
inInterpreter.Out() << inInterpreter.StateMachine().GetStateValue( state.Name().c_str() );
return true;
}
bool
PathType::Exists( CommandInterpreter& inInterpreter )
{
string path = inInterpreter.GetToken();
bool result = FileUtils::IsFile( path ) || FileUtils::IsDirectory( path );
inInterpreter.Out() << ( result ? "true" : "false" );
return true;
}
bool
DirectoryType::Make( CommandInterpreter& inInterpreter )
{
string dir = inInterpreter.GetToken();
if( !FileUtils::MakeDirectory( dir ) )
inInterpreter.Out() << "Could not make directory \"" << dir << "\"";
return true;
}
bool
LineType::Read( CommandInterpreter& inInterpreter )
{
string line;
if( !inInterpreter.ReadLine( line ) )
throw bciexception( "No input associated with command interpreter of type " << ClassName( typeid( inInterpreter ) ) );
inInterpreter.Out() << line;
return true;
}
bool
StatesType::Clear( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
if( inInterpreter.StateMachine().SystemState() != StateMachine::Idle )
throw bciexception( "Must be in idle state to clear states" );
inInterpreter.StateMachine().States().Clear();
return true;
}
bool
FileType::Extract( CommandInterpreter& inInterpreter )
{
string file = inInterpreter.GetToken();
if( !::stricmp( file.c_str(), "Base" ) )
inInterpreter.Out() << FileUtils::ExtractBase( inInterpreter.GetToken() );
else
inInterpreter.Out() << FileUtils::ExtractFile( file );
return true;
}
bool
DirectoryType::Rename( CommandInterpreter& inInterpreter )
{
string dir = inInterpreter.GetToken(),
newName = inInterpreter.GetToken();
if( !FileUtils::IsDirectory( dir ) )
throw bciexception( "There is no directory named \"" << dir << "\"" );
if( !FileUtils::Rename( dir, newName ) )
throw bciexception( "Could not rename \"" << dir << "\" to \"" << newName << "\"" );
return true;
}
bool
FileType::Rename( CommandInterpreter& inInterpreter )
{
string file = inInterpreter.GetToken(),
newName = inInterpreter.GetToken();
if( !FileUtils::IsFile( file ) )
throw bciexception( "There is no file named \"" << file << "\"" );
if( !FileUtils::Rename( file, newName ) )
throw bciexception( "Could not rename file \"" << file << "\" to \"" << newName << "\"" );
return true;
}
bool
StatesType::List( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
string pattern = inInterpreter.GetRemainingTokens();
if( pattern.empty() )
pattern = "*";
const StateList& states = inInterpreter.StateMachine().States();
for( int i = 0; i < states.Size(); ++i )
if( WildcardMatch( pattern, states[i].Name(), false ) )
inInterpreter.Out() << states[i] << '\n';
return true;
}
bool
DirectoryType::List( CommandInterpreter& inInterpreter )
{
string args;
#if _WIN32
args = "/n ";
#else
args = "-l ";
#endif
string remainder = inInterpreter.GetRemainingTokens();
args += remainder;
inInterpreter.Out() << ListDirectory( args );
return true;
}
void
Property::DumpDescription (CommandInterpreter &interpreter,
Stream &strm,
uint32_t output_width,
bool display_qualified_name) const
{
if (m_value_sp)
{
const char *desc = GetDescription();
if (desc)
{
StreamString qualified_name;
const OptionValueProperties *sub_properties = m_value_sp->GetAsProperties();
if (sub_properties)
{
strm.EOL();
if (m_value_sp->DumpQualifiedName(qualified_name))
strm.Printf("'%s' variables:\n\n", qualified_name.GetString().c_str());
sub_properties->DumpAllDescriptions(interpreter, strm);
}
else
{
if (desc)
{
if (display_qualified_name)
{
StreamString qualified_name;
DumpQualifiedName(qualified_name);
interpreter.OutputFormattedHelpText (strm,
qualified_name.GetString().c_str(),
"--",
desc,
output_width);
}
else
{
interpreter.OutputFormattedHelpText (strm,
m_name.GetCString(),
"--",
desc,
output_width);
}
}
}
}
}
}
int
CommandCompletions::SettingsNames (CommandInterpreter &interpreter,
const char *partial_setting_name,
int match_start_point,
int max_return_elements,
SearchFilter *searcher,
bool &word_complete,
StringList &matches)
{
// Cache the full setting name list
static StringList g_property_names;
if (g_property_names.GetSize() == 0)
{
// Generate the full setting name list on demand
lldb::OptionValuePropertiesSP properties_sp (interpreter.GetDebugger().GetValueProperties());
if (properties_sp)
{
StreamString strm;
properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
const std::string &str = strm.GetString();
g_property_names.SplitIntoLines(str.c_str(), str.size());
}
}
size_t exact_matches_idx = SIZE_MAX;
const size_t num_matches = g_property_names.AutoComplete (partial_setting_name, matches, exact_matches_idx);
word_complete = exact_matches_idx != SIZE_MAX;
return num_matches;
}
bool
OptionGroupFormat::ParserGDBFormatLetter (CommandInterpreter &interpreter, char format_letter, Format &format, uint32_t &byte_size)
{
m_has_gdb_format = true;
switch (format_letter)
{
case 'o': format = eFormatOctal; m_prev_gdb_format = format_letter; return true;
case 'x': format = eFormatHex; m_prev_gdb_format = format_letter; return true;
case 'd': format = eFormatDecimal; m_prev_gdb_format = format_letter; return true;
case 'u': format = eFormatUnsigned; m_prev_gdb_format = format_letter; return true;
case 't': format = eFormatBinary; m_prev_gdb_format = format_letter; return true;
case 'f': format = eFormatFloat; m_prev_gdb_format = format_letter; return true;
case 'a': format = eFormatAddressInfo;
{
ExecutionContext exe_ctx(interpreter.GetExecutionContext());
Target *target = exe_ctx.GetTargetPtr();
if (target)
byte_size = target->GetArchitecture().GetAddressByteSize();
m_prev_gdb_format = format_letter;
return true;
}
case 'i': format = eFormatInstruction; m_prev_gdb_format = format_letter; return true;
case 'c': format = eFormatChar; m_prev_gdb_format = format_letter; return true;
case 's': format = eFormatCString; m_prev_gdb_format = format_letter; return true;
case 'T': format = eFormatOSType; m_prev_gdb_format = format_letter; return true;
case 'A': format = eFormatHexFloat; m_prev_gdb_format = format_letter; return true;
case 'b': byte_size = 1; m_prev_gdb_size = format_letter; return true;
case 'h': byte_size = 2; m_prev_gdb_size = format_letter; return true;
case 'w': byte_size = 4; m_prev_gdb_size = format_letter; return true;
case 'g': byte_size = 8; m_prev_gdb_size = format_letter; return true;
default: break;
}
return false;
}
int
CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
const char *partial_file_name,
int match_start_point,
int max_return_elements,
SearchFilter *searcher,
bool &word_complete,
StringList &matches)
{
word_complete = true;
// Find some way to switch "include support files..."
SourceFileCompleter completer (interpreter,
false,
partial_file_name,
match_start_point,
max_return_elements,
matches);
if (searcher == nullptr)
{
lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
SearchFilterForUnconstrainedSearches null_searcher (target_sp);
completer.DoCompletion (&null_searcher);
}
else
{
completer.DoCompletion (searcher);
}
return matches.GetSize();
}
int
CommandCompletions::Symbols
(
CommandInterpreter &interpreter,
const char *partial_file_name,
int match_start_point,
int max_return_elements,
SearchFilter *searcher,
bool &word_complete,
StringList &matches)
{
word_complete = true;
SymbolCompleter completer (interpreter,
partial_file_name,
match_start_point,
max_return_elements,
matches);
if (searcher == NULL)
{
lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
SearchFilterForUnconstrainedSearches null_searcher (target_sp);
completer.DoCompletion (&null_searcher);
}
else
{
completer.DoCompletion (searcher);
}
return matches.GetSize();
}
int CommandCompletions::SettingsNames(CommandInterpreter &interpreter,
CompletionRequest &request,
SearchFilter *searcher) {
// Cache the full setting name list
static StringList g_property_names;
if (g_property_names.GetSize() == 0) {
// Generate the full setting name list on demand
lldb::OptionValuePropertiesSP properties_sp(
interpreter.GetDebugger().GetValueProperties());
if (properties_sp) {
StreamString strm;
properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
const std::string &str = strm.GetString();
g_property_names.SplitIntoLines(str.c_str(), str.size());
}
}
size_t exact_matches_idx = SIZE_MAX;
StringList matches;
g_property_names.AutoComplete(request.GetCursorArgumentPrefix(), matches,
exact_matches_idx);
request.SetWordComplete(exact_matches_idx != SIZE_MAX);
request.AddCompletions(matches);
return request.GetNumberOfMatches();
}
void
OptionGroupValueObjectDisplay::OptionParsingStarting (CommandInterpreter &interpreter)
{
// If these defaults change, be sure to modify AnyOptionWasSet().
show_types = false;
no_summary_depth = 0;
show_location = false;
flat_output = false;
use_objc = false;
max_depth = UINT32_MAX;
ptr_depth = 0;
use_synth = true;
be_raw = false;
ignore_cap = false;
run_validator = false;
Target *target = interpreter.GetExecutionContext().GetTargetPtr();
if (target != nullptr)
use_dynamic = target->GetPreferDynamicValue();
else
{
// If we don't have any targets, then dynamic values won't do us much good.
use_dynamic = lldb::eNoDynamicValues;
}
}
void callback( String& topic, String& message )
{
//Serial.print(topic);
//Serial.print(":");
//Serial.println(message);
interpreter.interpret( topic, message );
}
bool
StateType::Insert( CommandInterpreter& inInterpreter )
{
string name = inInterpreter.GetToken();
string line = inInterpreter.GetRemainder(),
stateline = name + " " + line + " 0 0";
State state;
istringstream iss( stateline );
if( !( iss >> state ) )
throw bciexception( "Invalid state definition" );
{
Lock lock( inInterpreter.StateMachine() );
switch( inInterpreter.StateMachine().SystemState() )
{
case StateMachine::Idle:
case StateMachine::WaitingForConnection:
case StateMachine::Publishing:
case StateMachine::Information:
break;
default:
throw bciexception( "Could not add state " << name << " to list after information phase" );
}
inInterpreter.StateMachine().States().Add( state );
}
inInterpreter.StateMachine().ExecuteCallback( BCI_OnState, stateline.c_str() );
inInterpreter.Log() << "Added state " << name << " to list";
return true;
}
bool
Interpreter::SignalType::Get( CommandInterpreter& inInterpreter )
{
Lock lock( inInterpreter.StateMachine() );
const GenericSignal& signal = inInterpreter.StateMachine().ControlSignal();
string name = inInterpreter.GetToken();
if( !::stricmp( name.c_str(), "Channels" ) )
{
inInterpreter.Out() << signal.Channels();
}
else if( !::stricmp( name.c_str(), "Elements" ) )
{
inInterpreter.Out() << signal.Elements();
}
else
{
CommandInterpreter::ArgumentList args;
inInterpreter.ParseArguments( name, args );
if( ::stricmp( name.c_str(), "Signal" ) )
throw bciexception( "Use 'Signal' to address the signal" );
if( args.size() != 1 || args[0].size() != 2 )
throw bciexception( "Expected two signal indices" );
int idx1 = ::atoi( args[0][0].c_str() ) - 1,
idx2 = ::atoi( args[0][1].c_str() ) - 1;
if( idx1 < 0 || idx2 < 0 || idx1 >= signal.Channels() || idx2 >= signal.Elements() )
throw bciexception( "Signal index out of range" );
inInterpreter.Out() << signal( idx1, idx2 );
}
return true;
}
bool
LineType::Write( CommandInterpreter& inInterpreter )
{
string args = inInterpreter.GetRemainingTokens(),
line;
istringstream iss( args );
ParserToken arg;
if( iss >> arg )
line = arg;
while( iss >> arg )
{
line += " ";
line += arg;
}
if( !inInterpreter.WriteLine( line ) )
throw bciexception( "No output associated with command interpreter of type " << ClassName( typeid( inInterpreter ) ) );
return true;
}
bool
DirectoryType::ForceRemove( CommandInterpreter& inInterpreter )
{
string dir = inInterpreter.GetToken();
if( !FileUtils::IsDirectory( dir ) )
throw bciexception( "There is no directory named \"" << dir << "\"" );
if( !FileUtils::RemoveDirectory( dir, true ) )
throw bciexception( "Could not remove directory \"" << dir << "\"" );
return true;
}
int
CommandCompletions::VariablePath (CommandInterpreter &interpreter,
const char *partial_name,
int match_start_point,
int max_return_elements,
SearchFilter *searcher,
bool &word_complete,
lldb_private::StringList &matches)
{
return Variable::AutoComplete (interpreter.GetExecutionContext(), partial_name, matches, word_complete);
}
bool
StateType::Set( CommandInterpreter& inInterpreter )
{
string name;
State::ValueType value = 0;
ostringstream oss;
{
Lock lock( inInterpreter.StateMachine() );
State& state = GetState( inInterpreter );
name = state.Name();
value = ::atoi( inInterpreter.GetToken().c_str() );
if( !inInterpreter.StateMachine().SetStateValue( name.c_str(), value ) )
throw bciexception( "Could not set state " << name << " to " << value );
// StateMachine::SetStateValue() does not set the value of the state object in its state list.
state.SetValue( value );
oss << state;
}
inInterpreter.StateMachine().ExecuteCallback( BCI_OnState, oss.str().c_str() );
inInterpreter.Log() << "Set state " << name << " to " << value;
return true;
}
bool
DirectoryType::ListSelection( CommandInterpreter& inInterpreter, const string& inDir, const string& inWildcard, bool (*inSelector)( const string& ) )
{
string dir = inDir.empty() ? "." : inDir,
wildcard = inWildcard.empty() ? "*" : inWildcard;
dir = FileUtils::CanonicalPath( dir );
FileUtils::List list;
if( !FileUtils::ListDirectory( dir, list ) )
throw bciexception( "Could not list directory \"" << dir << "\"" );
for( size_t i = 0; i < list.size(); ++i )
if( WildcardMatch( wildcard, list[i], false ) && inSelector( FileUtils::EnsureSeparator( dir ) + list[i] ) )
inInterpreter.Out() << list[i] << '\n';
return true;
}
