1 //===-- OptionGroupFormat.cpp -----------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/lldb-python.h" 11 12 #include "lldb/Interpreter/OptionGroupFormat.h" 13 14 // C Includes 15 // C++ Includes 16 // Other libraries and framework includes 17 // Project includes 18 #include "lldb/Core/ArchSpec.h" 19 #include "lldb/Interpreter/CommandInterpreter.h" 20 #include "lldb/Target/ExecutionContext.h" 21 #include "lldb/Target/Target.h" 22 #include "lldb/Utility/Utils.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 27 OptionGroupFormat::OptionGroupFormat (lldb::Format default_format, 28 uint64_t default_byte_size, 29 uint64_t default_count) : 30 m_format (default_format, default_format), 31 m_byte_size (default_byte_size, default_byte_size), 32 m_count (default_count, default_count), 33 m_prev_gdb_format('x'), 34 m_prev_gdb_size('w') 35 { 36 } 37 38 OptionGroupFormat::~OptionGroupFormat () 39 { 40 } 41 42 static OptionDefinition 43 g_option_table[] = 44 { 45 { LLDB_OPT_SET_1, false, "format" ,'f', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFormat , "Specify a format to be used for display."}, 46 { LLDB_OPT_SET_2, false, "gdb-format",'G', OptionParser::eRequiredArgument, NULL, 0, eArgTypeGDBFormat, "Specify a format using a GDB format specifier string."}, 47 { LLDB_OPT_SET_3, false, "size" ,'s', OptionParser::eRequiredArgument, NULL, 0, eArgTypeByteSize , "The size in bytes to use when displaying with the selected format."}, 48 { LLDB_OPT_SET_4, false, "count" ,'c', OptionParser::eRequiredArgument, NULL, 0, eArgTypeCount , "The number of total items to display."}, 49 }; 50 51 uint32_t 52 OptionGroupFormat::GetNumDefinitions () 53 { 54 if (m_byte_size.GetDefaultValue() < UINT64_MAX) 55 { 56 if (m_count.GetDefaultValue() < UINT64_MAX) 57 return 4; 58 else 59 return 3; 60 } 61 return 2; 62 } 63 64 const OptionDefinition * 65 OptionGroupFormat::GetDefinitions () 66 { 67 return g_option_table; 68 } 69 70 Error 71 OptionGroupFormat::SetOptionValue (CommandInterpreter &interpreter, 72 uint32_t option_idx, 73 const char *option_arg) 74 { 75 Error error; 76 const int short_option = g_option_table[option_idx].short_option; 77 78 switch (short_option) 79 { 80 case 'f': 81 error = m_format.SetValueFromCString (option_arg); 82 break; 83 84 case 'c': 85 if (m_count.GetDefaultValue() == 0) 86 { 87 error.SetErrorString ("--count option is disabled"); 88 } 89 else 90 { 91 error = m_count.SetValueFromCString (option_arg); 92 if (m_count.GetCurrentValue() == 0) 93 error.SetErrorStringWithFormat("invalid --count option value '%s'", option_arg); 94 } 95 break; 96 97 case 's': 98 if (m_byte_size.GetDefaultValue() == 0) 99 { 100 error.SetErrorString ("--size option is disabled"); 101 } 102 else 103 { 104 error = m_byte_size.SetValueFromCString (option_arg); 105 if (m_byte_size.GetCurrentValue() == 0) 106 error.SetErrorStringWithFormat("invalid --size option value '%s'", option_arg); 107 } 108 break; 109 110 case 'G': 111 { 112 char *end = NULL; 113 const char *gdb_format_cstr = option_arg; 114 uint64_t count = 0; 115 if (::isdigit (gdb_format_cstr[0])) 116 { 117 count = strtoull (gdb_format_cstr, &end, 0); 118 119 if (option_arg != end) 120 gdb_format_cstr = end; // We have a valid count, advance the string position 121 else 122 count = 0; 123 } 124 125 Format format = eFormatDefault; 126 uint32_t byte_size = 0; 127 128 while (ParserGDBFormatLetter (interpreter, gdb_format_cstr[0], format, byte_size)) 129 { 130 ++gdb_format_cstr; 131 } 132 133 // We the first character of the "gdb_format_cstr" is not the 134 // NULL terminator, we didn't consume the entire string and 135 // something is wrong. Also, if none of the format, size or count 136 // was specified correctly, then abort. 137 if (gdb_format_cstr[0] || (format == eFormatInvalid && byte_size == 0 && count == 0)) 138 { 139 // Nothing got set correctly 140 error.SetErrorStringWithFormat ("invalid gdb format string '%s'", option_arg); 141 return error; 142 } 143 144 // At least one of the format, size or count was set correctly. 145 // Anything that wasn't set correctly should be set to the 146 // previous default 147 if (format == eFormatInvalid) 148 ParserGDBFormatLetter (interpreter, m_prev_gdb_format, format, byte_size); 149 150 const bool byte_size_enabled = m_byte_size.GetDefaultValue() < UINT64_MAX; 151 const bool count_enabled = m_count.GetDefaultValue() < UINT64_MAX; 152 if (byte_size_enabled) 153 { 154 // Byte size is enabled 155 if (byte_size == 0) 156 ParserGDBFormatLetter (interpreter, m_prev_gdb_size, format, byte_size); 157 } 158 else 159 { 160 // Byte size is disabled, make sure it wasn't specified 161 // but if this is an address, it's actually necessary to 162 // specify one so don't error out 163 if (byte_size > 0 && format != lldb::eFormatAddressInfo) 164 { 165 error.SetErrorString ("this command doesn't support specifying a byte size"); 166 return error; 167 } 168 } 169 170 if (count_enabled) 171 { 172 // Count is enabled and was not set, set it to the default for gdb format statements (which is 1). 173 if (count == 0) 174 count = 1; 175 } 176 else 177 { 178 // Count is disabled, make sure it wasn't specified 179 if (count > 0) 180 { 181 error.SetErrorString ("this command doesn't support specifying a count"); 182 return error; 183 } 184 } 185 186 m_format.SetCurrentValue (format); 187 m_format.SetOptionWasSet (); 188 if (byte_size_enabled) 189 { 190 m_byte_size.SetCurrentValue (byte_size); 191 m_byte_size.SetOptionWasSet (); 192 } 193 if (count_enabled) 194 { 195 m_count.SetCurrentValue(count); 196 m_count.SetOptionWasSet (); 197 } 198 } 199 break; 200 201 default: 202 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 203 break; 204 } 205 206 return error; 207 } 208 209 bool 210 OptionGroupFormat::ParserGDBFormatLetter (CommandInterpreter &interpreter, char format_letter, Format &format, uint32_t &byte_size) 211 { 212 m_has_gdb_format = true; 213 switch (format_letter) 214 { 215 case 'o': format = eFormatOctal; m_prev_gdb_format = format_letter; return true; 216 case 'x': format = eFormatHex; m_prev_gdb_format = format_letter; return true; 217 case 'd': format = eFormatDecimal; m_prev_gdb_format = format_letter; return true; 218 case 'u': format = eFormatUnsigned; m_prev_gdb_format = format_letter; return true; 219 case 't': format = eFormatBinary; m_prev_gdb_format = format_letter; return true; 220 case 'f': format = eFormatFloat; m_prev_gdb_format = format_letter; return true; 221 case 'a': format = eFormatAddressInfo; 222 { 223 ExecutionContext exe_ctx(interpreter.GetExecutionContext()); 224 Target *target = exe_ctx.GetTargetPtr(); 225 if (target) 226 byte_size = target->GetArchitecture().GetAddressByteSize(); 227 m_prev_gdb_format = format_letter; 228 return true; 229 } 230 case 'i': format = eFormatInstruction; m_prev_gdb_format = format_letter; return true; 231 case 'c': format = eFormatChar; m_prev_gdb_format = format_letter; return true; 232 case 's': format = eFormatCString; m_prev_gdb_format = format_letter; return true; 233 case 'T': format = eFormatOSType; m_prev_gdb_format = format_letter; return true; 234 case 'A': format = eFormatHexFloat; m_prev_gdb_format = format_letter; return true; 235 case 'b': byte_size = 1; m_prev_gdb_size = format_letter; return true; 236 case 'h': byte_size = 2; m_prev_gdb_size = format_letter; return true; 237 case 'w': byte_size = 4; m_prev_gdb_size = format_letter; return true; 238 case 'g': byte_size = 8; m_prev_gdb_size = format_letter; return true; 239 default: break; 240 } 241 return false; 242 } 243 244 void 245 OptionGroupFormat::OptionParsingStarting (CommandInterpreter &interpreter) 246 { 247 m_format.Clear(); 248 m_byte_size.Clear(); 249 m_count.Clear(); 250 m_has_gdb_format = false; 251 } 252