Specify a language to use when parsing breakpoint identifiers.

[dawn]

Summary

The language must be known in order to correctly set the name_type_mask for languages like Pascal and Java. For example, to set a breakpoint on 'ns.foo' for a Pascal function 'foo' in namespace 'ns', we need to know that the language is Pascal in order to set the lookup masks to (eFunctionNameTypeMethod | eFunctionNameTypeBase) and the basename to "foo", just as we would in C++ for 'ns::foo'.

Previous patch (rejected):
This patch solves this problem by using the language of the selected frame (similar to gdb). Getting the language from user settings is also planned. This patch (and others) paves the way for the PascalLanguageRuntime support to come, which will be called if the language is Pascal.

New patch:
Target and breakpoints options were added:

breakpoint set --language lang --name func
settings set target.language pascal

These specify the Language to use when interpreting the breakpoint's expression (note: currently only implemented for breakpoints on identifiers). If the breakpoint language is not set, the target.language setting is used. These are needed This support is required by Pascal, for example, to set breakpoint at 'ns.foo' for function 'foo' in namespace 'ns'.
Tests on the language were also added to Module::PrepareForFunctionNameLookup for efficiency.

[dawn]

I expect this patch may draw up some controversy; if not acceptable, please advise on how to rework?
Greg, as the expert in this area, I would especially appreciate your feedback. Any others I could add to this review?

source/Core/Module.cpp

1745 ↗

(On Diff #29511)

tests for language will be added along with PascalLanguageRuntime support.

[clayborg]

The current frame really isn't a good indicator of the language that one should use for a breakpoint you are want to set by name.

I would rather see smarts go into Module::PrepareForFunctionNameLookup() and teach it to pull apart names like "ns.foo" and do the right thing. If a string comes into Module::PrepareForFunctionNameLookup() that contains <indentifier>.<indentifier> repeated as many times as needed (<indentifier>.<indentifier>.<indentifier>.<indentifier>) then we should correctly pull those apart and search for "foo" and then match against "ns.foo" (just like Module::PrepareForFunctionNameLookup() takes "ns::foo" and looks up "foo" and then matches agains "ns::foo"). I don't think we need a language indicator to tell us, we should be able to just break it up without that hint. We could provide a language hint to Module::PrepareForFunctionNameLookup() if we want to and then have the user specify "--language pascal" when doing the "breakpoint set --name ns.foo --language pascal", but we shouldn't be using any frame's compile unit language to do so.

[dawn]

Many thanks for taking the time to review! This new language support is painful... I'm grateful you're willing to work with me on it!!

I would rather see smarts go into Module::PrepareForFunctionNameLookup() and teach it to pull apart names like "ns.foo" and do the right thing. If a string comes into Module::PrepareForFunctionNameLookup() that contains <indentifier>.<indentifier> repeated as many times as needed (<indentifier>.<indentifier>.<indentifier>.<indentifier>) then we should correctly pull those apart and search for "foo" and then match against "ns.foo" (just like Module::PrepareForFunctionNameLookup() takes "ns::foo" and looks up "foo" and then matches agains "ns::foo"). I don't think we need a language indicator to tell us, we should be able to just break it up without that hint.

Currently this "pulling apart" happens via CPPLanguageRuntime. Do you want a version of
CPPLanguageRuntime that handle Pascals as well; a LanguageRuntime::ExtractContextAndIdentifier that is a superset and iterate through that? The problem is that the type mask can come in as eFunctionNameTypeMethod or eFunctionNameTypeBase. What C++ does with this (how it would split it apart) is different from how Pascal would split it. How would you workaround that?

We could provide a language hint to Module::PrepareForFunctionNameLookup() if we want to and then have the user specify "--language pascal" when doing the "breakpoint set --name ns.foo --language pascal", but we shouldn't be using any frame's compile unit language to do so.

Yes, I plan to add options like this, but wanted to use the frame's CU as the default, just as gdb does. It's a pain for a Pascal user to always have to specify "--language pascal" every time they want to set a breakpoint or evaluate a string. Agreed - using the frame's CU isn't perfect either, but it's the option gdb adopted, so has precedence and years of acceptance.

But I hear you, and will revise this patch to work off an option instead.

I had looked at adding language options settings... getting those options down to the code that needs to check them will change quite a few APIs. I also wasn't sure how best to specify the language - should it be a global setting that breakpoints and evaluation both use, or should each command have a "--language" option?

[dawn]

I will add breakpoint option:

breakpoint set --expr-language <lang> <expr>

and default option:

settings set target.expr-language <lang>

and submit revised patch. Sound good?

[jingham]

That sounds fine, except you shouldn't call the option "expr-language" because we expr is the common abbreviation for the "expression" command, but the breakpoint specifications are not in general expressions. In fact, the only breakpoint specifier that is an expression: --address would NOT take this option... So that's a confusing name.

Since you are only going to add the language options to versions of breakpoint set that take some form of identifier (--name, --method --base-name) maybe --identifier-language would be better?

Jim

[clayborg]

I would like to see the following:

• Add a new class named PascalLanguageRuntime and have it be able to figure out how to chop pascal names up into a basename and the larger string to then compare against.
• Add a --language <language> to "breakpoint set" and pass it along if needed
• Modify the Module::PrepareForFunctionNameLookup() to look at the language (which should default to "eLanguageTypeUnknown") and skip C++ if language it not eLanguageTypeUnknown and not related to C++. Have it call functions in your new PascalLanguageRuntime like a new (at least make PascalLanguageRuntime::ExtractContextAndIdentifier(...)).

[dawn]

In D11119#205491, @jingham wrote:

That sounds fine, except you shouldn't call the option "expr-language" because [...]
Since you are only going to add the language options to versions of breakpoint set that take some form of identifier (--name, --method --base-name) maybe --identifier-language would be better?

Actually, I do plan for this option to apply to the expression in '--address <expr>' as well. The

settings set target.expr-language <lang>

is intended to affect how expressions used in all commands are parsed and interpreted. This patch is just part of that bigger plan, by addressing how the name_type_masks are set.

We want the command options to match the target's setting for consistency. For example:

expr --expr-language <lang> <expr>
breakpoint set --expr-language <lang> <expr>

So '--identifier-language' isn't quite right, and my concern with plain '--language' is that

settings set target.language <lang>

might have users thinking it affects everything from unmangling to how the DWARF is read.

'--expr-language' seemed to to fit best to me. Would you agree?

[clayborg]

I think I would prefer --language and have the help text for this option specify what it means (it means expression language for --address and source language for file + line breakpoints).

[dawn]

In D11119#205834, @clayborg wrote:

I think I would prefer --language and have the help text for this option specify what it means (it means expression language for --address and source language for file + line breakpoints).

Ok, will do. At some point we may want a language option which affects everything from unmangling to how the DWARF is read, and it would make sense to reserve --language for that, but we can always change the names then.

I'll leave this review open until I have a revised one, just in case anyone else wants to comment on this...

[dawn]

This revised patch uses target and breakpoint options for determining the language instead of the selected frame's CU.

[clayborg]

Looks good as long as the test suite is happy. I worry about MacOSX tests.

[dawn]

In D11119#209209, @clayborg wrote:

Looks good as long as the test suite is happy. I worry about MacOSX tests.

All tests passed locally. Will watch for build failures...

lldb/trunk/include/lldb/Breakpoint/BreakpointResolverName.h

 class BreakpointResolverName:
     public BreakpointResolver
 {
 public:
 
     BreakpointResolverName (Breakpoint *bkpt,
                             const char *name,
                             uint32_t name_type_mask,
+                            lldb::LanguageType language,
                             Breakpoint::MatchType type,
                             bool skip_prologue);
 
     // This one takes an array of names.  It is always MatchType = Exact.
     BreakpointResolverName (Breakpoint *bkpt,
                             const char *names[],
                             size_t num_names,
                             uint32_t name_type_mask,
+                            lldb::LanguageType language,
                             bool skip_prologue);
 
     // This one takes a C++ array of names.  It is always MatchType = Exact.
     BreakpointResolverName (Breakpoint *bkpt,
                             std::vector<std::string> names,
                             uint32_t name_type_mask,
+                            lldb::LanguageType language,
                             bool skip_prologue);
 
     // Creates a function breakpoint by regular expression.  Takes over control of the lifespan of func_regex.
     BreakpointResolverName (Breakpoint *bkpt,
                             RegularExpression &func_regex,
                             bool skip_prologue);
 
     BreakpointResolverName (Breakpoint *bkpt,
struct LookupInfo
         void
         Prune (SymbolContextList &sc_list,
                size_t start_idx) const;
     };
     std::vector<LookupInfo> m_lookups;
     ConstString m_class_name;
     RegularExpression m_regex;
     Breakpoint::MatchType m_match_type;
+    lldb::LanguageType m_language;
     bool m_skip_prologue;
 
     void
     AddNameLookup (const ConstString &name, uint32_t name_type_mask);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_BreakpointResolverName_h_

lldb/trunk/include/lldb/Core/Module.h

     ///
     /// @param[in] name
     ///     The user supplied name to use in the lookup
     ///
     /// @param[in] name_type_mask
     ///     The mask of bits from lldb::FunctionNameType enumerations
     ///     that tell us what kind of name we are looking for.
     ///
+    /// @param[out] language
+    ///     If known, the language to use for determining the
+    ///     lookup_name_type_mask.
+    ///
     /// @param[out] lookup_name
     ///     The actual name that will be used when calling
     ///     SymbolVendor::FindFunctions() or Symtab::FindFunctionSymbols()
     ///
     /// @param[out] lookup_name_type_mask
     ///     The actual name mask that should be used in the calls to
     ///     SymbolVendor::FindFunctions() or Symtab::FindFunctionSymbols()
     ///
     /// @param[out] match_name_after_lookup
     ///     A boolean that indicates if we need to iterate through any
     ///     match results obtained from SymbolVendor::FindFunctions() or
     ///     Symtab::FindFunctionSymbols() to see if the name contains
     ///     \a name. For example if \a name is "a::b", this function will
     ///     return a \a lookup_name of "b", with \a match_name_after_lookup
     ///     set to true to indicate any matches will need to be checked
     ///     to make sure they contain \a name.
     //------------------------------------------------------------------
     static void
     PrepareForFunctionNameLookup (const ConstString &name,
                                   uint32_t name_type_mask,
+                                  lldb::LanguageType language,
                                   ConstString &lookup_name,
                                   uint32_t &lookup_name_type_mask,
                                   bool &match_name_after_lookup);
 
 protected:
     //------------------------------------------------------------------
     // Member Variables
     //------------------------------------------------------------------

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

//    GetQualifiedName (Stream &strm);
     {
         return false;
     }
 
 
     OptionValueArch *
     GetPropertyAtIndexAsOptionValueArch (const ExecutionContext *exe_ctx, uint32_t idx) const;
 
+    OptionValueLanguage *
+    GetPropertyAtIndexAsOptionValueLanguage (const ExecutionContext *exe_ctx, uint32_t idx) const;
+
     bool
     GetPropertyAtIndexAsArgs (const ExecutionContext *exe_ctx, uint32_t idx, Args &args) const;
 
     bool
     SetPropertyAtIndexFromArgs (const ExecutionContext *exe_ctx, uint32_t idx, const Args &args);
     
     bool
     GetPropertyAtIndexAsBoolean (const ExecutionContext *exe_ctx, uint32_t idx, bool fail_value) const;

lldb/trunk/include/lldb/Target/LanguageRuntime.h

public:
     GetNameForLanguageType (lldb::LanguageType language);
 
     static void
     PrintAllLanguages (Stream &s, const char *prefix, const char *suffix);
 
     static bool
     LanguageIsCPlusPlus (lldb::LanguageType language);
     
+    static bool
+    LanguageIsObjC (lldb::LanguageType language);
+    
+    static bool
+    LanguageIsC (lldb::LanguageType language);
+    
+    static bool
+    LanguageIsPascal (lldb::LanguageType language);
+    
     Process *
     GetProcess()
     {
         return m_process;
     }
 
     virtual lldb::BreakpointResolverSP
     CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp) = 0;

lldb/trunk/include/lldb/Target/Target.h

//    SetDisassemblyFlavor(const char *flavor);
     GetStandardErrorPath () const;
     
     void
     SetStandardErrorPath (const char *path);
     
     bool
     GetBreakpointsConsultPlatformAvoidList ();
     
+    lldb::LanguageType
+    GetLanguage () const;
+
     const char *
     GetExpressionPrefixContentsAsCString ();
 
     bool
     GetUseHexImmediates() const;
 
     bool
     GetUseFastStepping() const;
public:
     // When "skip_prologue is set to eLazyBoolCalculate, we use the current target 
     // setting, else we use the values passed in.
     // func_name_type_mask is or'ed values from the FunctionNameType enum.
     lldb::BreakpointSP
     CreateBreakpoint (const FileSpecList *containingModules,
                       const FileSpecList *containingSourceFiles,
                       const char *func_name,
                       uint32_t func_name_type_mask, 
+                      lldb::LanguageType language,
                       LazyBool skip_prologue,
                       bool internal,
                       bool request_hardware);
                       
     lldb::BreakpointSP
     CreateExceptionBreakpoint (enum lldb::LanguageType language,
                                bool catch_bp,
                                bool throw_bp,
                                bool internal,
                                Args *additional_args = nullptr,
                                Error *additional_args_error = nullptr);
     
     // This is the same as the func_name breakpoint except that you can specify a vector of names.  This is cheaper
     // than a regular expression breakpoint in the case where you just want to set a breakpoint on a set of names
     // you already know.
     // func_name_type_mask is or'ed values from the FunctionNameType enum.
     lldb::BreakpointSP
     CreateBreakpoint (const FileSpecList *containingModules,
                       const FileSpecList *containingSourceFiles,
                       const char *func_names[],
                       size_t num_names, 
                       uint32_t func_name_type_mask, 
+                      lldb::LanguageType language,
                       LazyBool skip_prologue,
                       bool internal,
                       bool request_hardware);
 
     lldb::BreakpointSP
     CreateBreakpoint (const FileSpecList *containingModules,
                       const FileSpecList *containingSourceFiles,
                       const std::vector<std::string> &func_names,
                       uint32_t func_name_type_mask,
+                      lldb::LanguageType language,
                       LazyBool skip_prologue,
                       bool internal,
                       bool request_hardware);
 
 
     // Use this to create a general breakpoint:
     lldb::BreakpointSP
     CreateBreakpoint (lldb::SearchFilterSP &filter_sp,

lldb/trunk/source/API/SBTarget.cpp

if (target_sp.get())
 
         const bool internal = false;
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolCalculate;
         if (module_name && module_name[0])
         {
             FileSpecList module_spec_list;
             module_spec_list.Append (FileSpec (module_name, false));
-            *sb_bp = target_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal, hardware);
+            *sb_bp = target_sp->CreateBreakpoint (&module_spec_list, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, skip_prologue, internal, hardware);
         }
         else
         {
-            *sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, skip_prologue, internal, hardware);
+            *sb_bp = target_sp->CreateBreakpoint (NULL, NULL, symbol_name, eFunctionNameTypeAuto, eLanguageTypeUnknown, skip_prologue, internal, hardware);
         }
     }
 
     if (log)
         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", module=\"%s\") => SBBreakpoint(%p)",
                      static_cast<void*>(target_sp.get()), symbol_name,
                      module_name, static_cast<void*>(sb_bp.get()));
 
if (target_sp && symbol_name && symbol_name[0])
         const bool internal = false;
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolCalculate;
         Mutex::Locker api_locker (target_sp->GetAPIMutex());
         *sb_bp = target_sp->CreateBreakpoint (module_list.get(), 
                                               comp_unit_list.get(),
                                               symbol_name,
                                               name_type_mask,
+                                              eLanguageTypeUnknown,
                                               skip_prologue,
                                               internal,
                                               hardware);
     }
 
     if (log)
         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbol=\"%s\", name_type: %d) => SBBreakpoint(%p)",
                      static_cast<void*>(target_sp.get()), symbol_name,
if (target_sp && num_names > 0)
         const bool internal = false;
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolCalculate;
         *sb_bp = target_sp->CreateBreakpoint (module_list.get(), 
                                                 comp_unit_list.get(), 
                                                 symbol_names,
                                                 num_names,
                                                 name_type_mask, 
+                                                eLanguageTypeUnknown,
                                                 skip_prologue,
                                                 internal,
                                                 hardware);
     }
 
     if (log)
     {
         log->Printf ("SBTarget(%p)::BreakpointCreateByName (symbols={",

lldb/trunk/source/Breakpoint/BreakpointResolverName.cpp

 #include "lldb/Target/ObjCLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
                                                 const char *name_cstr,
                                                 uint32_t name_type_mask,
+                                                LanguageType language,
                                                 Breakpoint::MatchType type,
                                                 bool skip_prologue) :
     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
     m_class_name (),
     m_regex (),
     m_match_type (type),
+    m_language (language),
     m_skip_prologue (skip_prologue)
 {
     
     if (m_match_type == Breakpoint::Regexp)
     {
         if (!m_regex.Compile (name_cstr))
         {
             Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 
             if (log)
                 log->Warning ("function name regexp: \"%s\" did not compile.", name_cstr);
         }
     }
     else
     {
         AddNameLookup (ConstString(name_cstr), name_type_mask);
     }
 }
 
 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
                                                 const char *names[],
                                                 size_t num_names,
                                                 uint32_t name_type_mask,
+                                                LanguageType language,
                                                 bool skip_prologue) :
     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
     m_match_type (Breakpoint::Exact),
+    m_language (language),
     m_skip_prologue (skip_prologue)
 {
     for (size_t i = 0; i < num_names; i++)
     {
         AddNameLookup (ConstString (names[i]), name_type_mask);
     }
 }
 
 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
                                                 std::vector<std::string> names,
                                                 uint32_t name_type_mask,
+                                                LanguageType language,
                                                 bool skip_prologue) :
     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
     m_match_type (Breakpoint::Exact),
+    m_language (language),
     m_skip_prologue (skip_prologue)
 {
     for (const std::string& name : names)
     {
         AddNameLookup (ConstString (name.c_str(), name.size()), name_type_mask);
     }
 }
 
 BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt,
                                                 RegularExpression &func_regex,
                                                 bool skip_prologue) :
     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
     m_class_name (NULL),
     m_regex (func_regex),
     m_match_type (Breakpoint::Regexp),
+    m_language (eLanguageTypeUnknown),
     m_skip_prologue (skip_prologue)
 {
 }
 
 BreakpointResolverName::BreakpointResolverName
 (
     Breakpoint *bkpt,
     const char *class_name,
     const char *method,
     Breakpoint::MatchType type,
     bool skip_prologue
 ) :
     BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
     m_class_name (class_name),
     m_regex (),
     m_match_type (type),
+    m_language (eLanguageTypeUnknown),
     m_skip_prologue (skip_prologue)
 {
     LookupInfo lookup;
     lookup.name.SetCString(method);
     lookup.lookup_name = lookup.name;
     lookup.name_type_mask = eFunctionNameTypeMethod;
     lookup.match_name_after_lookup = false;
     m_lookups.push_back (lookup);
 }
 
 BreakpointResolverName::~BreakpointResolverName ()
 {
 }
 
 BreakpointResolverName::BreakpointResolverName(const BreakpointResolverName &rhs) :
     BreakpointResolver(rhs.m_breakpoint, BreakpointResolver::NameResolver),
     m_lookups(rhs.m_lookups),
     m_class_name(rhs.m_class_name),
     m_regex(rhs.m_regex),
     m_match_type (rhs.m_match_type),
+    m_language (rhs.m_language),
     m_skip_prologue (rhs.m_skip_prologue)
 {
 
 }
 
 void
 BreakpointResolverName::AddNameLookup (const ConstString &name, uint32_t name_type_mask)
 {
if (objc_method.IsValid(false))
             lookup.match_name_after_lookup = false;
             m_lookups.push_back (lookup);
         }
     }
     else
     {
         LookupInfo lookup;
         lookup.name = name;
-        Module::PrepareForFunctionNameLookup(lookup.name, name_type_mask, lookup.lookup_name, lookup.name_type_mask, lookup.match_name_after_lookup);
+        Module::PrepareForFunctionNameLookup(lookup.name, name_type_mask, m_language, lookup.lookup_name, lookup.name_type_mask, lookup.match_name_after_lookup);
         m_lookups.push_back (lookup);
     }
 }
 
 
 void
 BreakpointResolverName::LookupInfo::Prune (SymbolContextList &sc_list, size_t start_idx) const
 {

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

public:
             m_thread_id(LLDB_INVALID_THREAD_ID),
             m_thread_index (UINT32_MAX),
             m_thread_name(),
             m_queue_name(),
             m_catch_bp (false),
             m_throw_bp (true),
             m_hardware (false),
             m_exception_language (eLanguageTypeUnknown),
+            m_language (lldb::eLanguageTypeUnknown),
             m_skip_prologue (eLazyBoolCalculate),
             m_one_shot (false),
             m_all_files (false),
             m_move_to_nearest_code (eLazyBoolCalculate)
         {
         }
 
 
public:
                 {
                     bool success;
                     m_line_num = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("invalid line number: %s.", option_arg);
                     break;
                 }
 
+                case 'L':
+                    m_language = LanguageRuntime::GetLanguageTypeFromString (option_arg);
+                    if (m_language == eLanguageTypeUnknown)
+                        error.SetErrorStringWithFormat ("Unknown language type: '%s' for breakpoint", option_arg);
+                    break;
+
                 case 'm':
                 {
                     bool success;
                     bool value;
                     value = Args::StringToBoolean (option_arg, true, &success);
                     if (value)
                         m_move_to_nearest_code = eLazyBoolYes;
                     else
public:
             m_thread_id = LLDB_INVALID_THREAD_ID;
             m_thread_index = UINT32_MAX;
             m_thread_name.clear();
             m_queue_name.clear();
             m_catch_bp = false;
             m_throw_bp = true;
             m_hardware = false;
             m_exception_language = eLanguageTypeUnknown;
+            m_language = lldb::eLanguageTypeUnknown;
             m_skip_prologue = eLazyBoolCalculate;
             m_one_shot = false;
             m_use_dummy = false;
             m_breakpoint_names.clear();
             m_all_files = false;
             m_exception_extra_args.Clear();
             m_move_to_nearest_code = eLazyBoolCalculate;
         }
public:
         lldb::tid_t m_thread_id;
         uint32_t m_thread_index;
         std::string m_thread_name;
         std::string m_queue_name;
         bool m_catch_bp;
         bool m_throw_bp;
         bool m_hardware; // Request to use hardware breakpoints
         lldb::LanguageType m_exception_language;
+        lldb::LanguageType m_language;
         LazyBool m_skip_prologue;
         bool m_one_shot;
         bool m_use_dummy;
         bool m_all_files;
         Args m_exception_extra_args;
         LazyBool m_move_to_nearest_code;
 
     };
DoExecute (Args& command,
                     
                     if (name_type_mask == 0)
                         name_type_mask = eFunctionNameTypeAuto;
                     
                     bp = target->CreateBreakpoint (&(m_options.m_modules),
                                                    &(m_options.m_filenames),
                                                    m_options.m_func_names,
                                                    name_type_mask,
+                                                   m_options.m_language,
                                                    m_options.m_skip_prologue,
                                                    internal,
                                                    m_options.m_hardware).get();
                 }
                 break;
 
             case eSetTypeFunctionRegexp: // Breakpoint by regular expression function name
                 {
private:
     CommandOptions m_options;
 };
 // If an additional option set beyond LLDB_OPTION_SET_10 is added, make sure to
 // update the numbers passed to LLDB_OPT_SET_FROM_TO(...) appropriately.
 #define LLDB_OPT_FILE ( LLDB_OPT_SET_FROM_TO(1, 9) & ~LLDB_OPT_SET_2 )
 #define LLDB_OPT_NOT_10 ( LLDB_OPT_SET_FROM_TO(1, 10) & ~LLDB_OPT_SET_10 )
 #define LLDB_OPT_SKIP_PROLOGUE ( LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3,8) )
 #define LLDB_OPT_MOVE_TO_NEAREST_CODE ( LLDB_OPT_SET_1 | LLDB_OPT_SET_9 )
+#define LLDB_OPT_EXPR_LANGUAGE ( LLDB_OPT_SET_FROM_TO(3, 8) & ~LLDB_OPT_SET_7 )
 
 OptionDefinition
 CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
 {
     { LLDB_OPT_NOT_10, false, "shlib", 's', OptionParser::eRequiredArgument, NULL, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName,
         "Set the breakpoint only in this shared library.  "
         "Can repeat this option multiple times to specify multiple shared libraries."},
 
CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
 
     { LLDB_OPT_SET_10, false, "on-catch", 'h', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,
         "Set the breakpoint on exception catcH." },
 
 //  Don't add this option till it actually does something useful...
 //    { LLDB_OPT_SET_10, false, "exception-typename", 'O', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeTypeName,
 //        "The breakpoint will only stop if an exception Object of this type is thrown.  Can be repeated multiple times to stop for multiple object types" },
 
+    { LLDB_OPT_EXPR_LANGUAGE, false, "language", 'L', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage,
+        "Specifies the Language to use when interpreting the breakpoint's expression (note: currently only implemented for breakpoints identifiers).  If not set the target.language setting is used." },
+
     { LLDB_OPT_SKIP_PROLOGUE, false, "skip-prologue", 'K', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,
         "sKip the prologue if the breakpoint is at the beginning of a function.  If not set the target.skip-prologue setting is used." },
 
     { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,
         "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
 
     { LLDB_OPT_SET_ALL, false, "breakpoint-name", 'N', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBreakpointName,
         "Adds this to the list of names for this breakopint."},

lldb/trunk/source/Core/Module.cpp

Module::FindFunctions (const ConstString &name,
     
     if (name_type_mask & eFunctionNameTypeAuto)
     {
         ConstString lookup_name;
         uint32_t lookup_name_type_mask = 0;
         bool match_name_after_lookup = false;
         Module::PrepareForFunctionNameLookup (name,
                                               name_type_mask,
+                                              eLanguageTypeUnknown, // TODO: add support
                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
         
         if (symbols)
         {
             symbols->FindFunctions(lookup_name,
                                    namespace_decl,
if (versions && num_versions)
             versions[i] = LLDB_INVALID_MODULE_VERSION;
     }
     return 0;
 }
 
 void
 Module::PrepareForFunctionNameLookup (const ConstString &name,
                                       uint32_t name_type_mask,
+                                      LanguageType language,
                                       ConstString &lookup_name,
                                       uint32_t &lookup_name_type_mask,
                                       bool &match_name_after_lookup)
 {
     const char *name_cstr = name.GetCString();
     lookup_name_type_mask = eFunctionNameTypeNone;
     match_name_after_lookup = false;
 
     llvm::StringRef basename;
     llvm::StringRef context;
     
     if (name_type_mask & eFunctionNameTypeAuto)
     {
         if (CPPLanguageRuntime::IsCPPMangledName (name_cstr))
             lookup_name_type_mask = eFunctionNameTypeFull;
-        else if (ObjCLanguageRuntime::IsPossibleObjCMethodName (name_cstr))
+        else if ((language == eLanguageTypeUnknown ||
+                  LanguageRuntime::LanguageIsObjC(language)) &&
+                 ObjCLanguageRuntime::IsPossibleObjCMethodName (name_cstr))
             lookup_name_type_mask = eFunctionNameTypeFull;
+        else if (LanguageRuntime::LanguageIsC(language))
+        {
+            lookup_name_type_mask = eFunctionNameTypeFull;
+        }
         else
         {
-            if (ObjCLanguageRuntime::IsPossibleObjCSelector(name_cstr))
+            if ((language == eLanguageTypeUnknown ||
+                 LanguageRuntime::LanguageIsObjC(language)) &&
+                ObjCLanguageRuntime::IsPossibleObjCSelector(name_cstr))
                 lookup_name_type_mask |= eFunctionNameTypeSelector;
             
             CPPLanguageRuntime::MethodName cpp_method (name);
             basename = cpp_method.GetBasename();
             if (basename.empty())
             {
                 if (CPPLanguageRuntime::ExtractContextAndIdentifier (name_cstr, context, basename))
                     lookup_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);

lldb/trunk/source/Core/ModuleList.cpp

ModuleList::FindFunctions (const ConstString &name,
     const size_t old_size = sc_list.GetSize();
     
     if (name_type_mask & eFunctionNameTypeAuto)
     {
         ConstString lookup_name;
         uint32_t lookup_name_type_mask = 0;
         bool match_name_after_lookup = false;
         Module::PrepareForFunctionNameLookup (name, name_type_mask,
+                                              eLanguageTypeUnknown, // TODO: add support
                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
     
         Mutex::Locker locker(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {
ModuleList::FindFunctionSymbols (const ConstString &name,
     const size_t old_size = sc_list.GetSize();
 
     if (name_type_mask & eFunctionNameTypeAuto)
     {
         ConstString lookup_name;
         uint32_t lookup_name_type_mask = 0;
         bool match_name_after_lookup = false;
         Module::PrepareForFunctionNameLookup (name, name_type_mask,
+                                              eLanguageTypeUnknown, // TODO: add support
                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
     
         Mutex::Locker locker(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

lldb/trunk/source/Interpreter/OptionValueLanguage.cpp

OptionValueLanguage::SetValueFromString (llvm::StringRef value, VarSetOperationType op)
     {
     case eVarSetOperationClear:
         Clear();
         break;
         
     case eVarSetOperationReplace:
     case eVarSetOperationAssign:
         {
-            LanguageType new_type = LanguageRuntime::GetLanguageTypeFromString(value.data());
+            ConstString lang_name(value.trim());
+            LanguageType new_type = LanguageRuntime::GetLanguageTypeFromString(lang_name.GetCString());
+            if (new_type)
+            {
                 m_value_was_set = true;
                 m_current_value = new_type;
             }
+            else
+            {
+                StreamString error_strm;
+                error_strm.Printf("invalid language type '%s', ", value.str().c_str());
+                error_strm.Printf("valid values are:\n");
+                LanguageRuntime::PrintAllLanguages(error_strm, "    ", "\n");
+                error.SetErrorString(error_strm.GetData());
+            }
+        }
         break;
         
     case eVarSetOperationInsertBefore:
     case eVarSetOperationInsertAfter:
     case eVarSetOperationRemove:
     case eVarSetOperationAppend:
     case eVarSetOperationInvalid:
         error = OptionValue::SetValueFromString(value, op);

lldb/trunk/source/Interpreter/OptionValueProperties.cpp

 OptionValueProperties::GetPropertyAtIndexAsOptionValueArch (const ExecutionContext *exe_ctx, uint32_t idx) const
 {
     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
     if (property)
         return property->GetValue()->GetAsArch();
     return nullptr;
 }
 
+OptionValueLanguage *
+OptionValueProperties::GetPropertyAtIndexAsOptionValueLanguage (const ExecutionContext *exe_ctx, uint32_t idx) const
+{
+    const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
+    if (property)
+        return property->GetValue()->GetAsLanguage();
+    return nullptr;
+}
+
 bool
 OptionValueProperties::GetPropertyAtIndexAsArgs (const ExecutionContext *exe_ctx, uint32_t idx, Args &args) const
 {
     const Property *property = GetPropertyAtIndex (exe_ctx, false, idx);
     if (property)
     {
         OptionValue *value = property->GetValue().get();
         if (value)

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (m_break_id == LLDB_INVALID_BREAK_ID && m_kernel.GetModule())
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolNo;
         FileSpecList module_spec_list;
         module_spec_list.Append (m_kernel.GetModule()->GetFileSpec());
         Breakpoint *bp = m_process->GetTarget().CreateBreakpoint (&module_spec_list,
                                                                   NULL,
                                                                   "OSKextLoadedKextSummariesUpdated",
                                                                   eFunctionNameTypeFull,
+                                                                  eLanguageTypeUnknown,
                                                                   skip_prologue,
                                                                   internal_bp,
                                                                   hardware).get();
 
         bp->SetCallback (DynamicLoaderDarwinKernel::BreakpointHitCallback, this, true);
         m_break_id = bp->GetID();
     }
 }

lldb/trunk/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

ItaniumABILanguageRuntime::CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions)
 
     if (for_expressions)
         exception_names.push_back(g_exception_throw_name);
     
     BreakpointResolverSP resolver_sp (new BreakpointResolverName (bkpt,
                                                                   exception_names.data(),
                                                                   exception_names.size(),
                                                                   eFunctionNameTypeBase,
+                                                                  eLanguageTypeC_plus_plus,
                                                                   eLazyBoolNo));
 
     return resolver_sp;
 }
 
 
 
 lldb::SearchFilterSP

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 AppleObjCRuntimeV1::CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp)
 {
     BreakpointResolverSP resolver_sp;
     
     if (throw_bp)
         resolver_sp.reset (new BreakpointResolverName (bkpt,
                                                        "objc_exception_throw",
                                                        eFunctionNameTypeBase,
+                                                       eLanguageTypeObjC,
                                                        Breakpoint::Exact,
                                                        eLazyBoolNo));
     // FIXME: don't do catch yet.
     return resolver_sp;
 }
 
 struct BufStruct {
     char contents[2048];

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 AppleObjCRuntimeV2::CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp)
 {
     BreakpointResolverSP resolver_sp;
     
     if (throw_bp)
         resolver_sp.reset (new BreakpointResolverName (bkpt,
                                                        "objc_exception_throw",
                                                        eFunctionNameTypeBase,
+                                                       eLanguageTypeObjC,
                                                        Breakpoint::Exact,
                                                        eLazyBoolNo));
     // FIXME: We don't do catch breakpoints for ObjC yet.
     // Should there be some way for the runtime to specify what it can do in this regard?
     return resolver_sp;
 }
 
 ClangUtilityFunction *

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

PlatformDarwin::SetThreadCreationBreakpoint (Target &target)
     bool internal = true;
     bool hardware = false;
     LazyBool skip_prologue = eLazyBoolNo;
     bp_sp = target.CreateBreakpoint (&bp_modules,
                                      NULL,
                                      g_bp_names,
                                      llvm::array_lengthof(g_bp_names),
                                      eFunctionNameTypeFull,
+                                     eLanguageTypeUnknown,
                                      skip_prologue,
                                      internal,
                                      hardware);
     bp_sp->SetBreakpointKind("thread-creation");
 
     return bp_sp;
 }
 

lldb/trunk/source/Target/LanguageRuntime.cpp

struct language_name_pair language_names[] =
     {   "c++14",            eLanguageTypeC_plus_plus_14 },
     {   "fortran03",        eLanguageTypeFortran03      },
     {   "fortran08",        eLanguageTypeFortran08      },
     // Vendor Extensions
     {   "mipsassem",        eLanguageTypeMipsAssembler  },
     {   "renderscript",     eLanguageTypeExtRenderScript},
     // Now synonyms, in arbitrary order
     {   "objc",             eLanguageTypeObjC           },
-    {   "objc++",           eLanguageTypeObjC_plus_plus }
+    {   "objc++",           eLanguageTypeObjC_plus_plus },
+    {   "pascal",           eLanguageTypePascal83       }
 };
 
 static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair);
 
 LanguageType
 LanguageRuntime::GetLanguageTypeFromString (const char *string)
 {
     for (uint32_t i = 0; i < num_languages; i++)
switch (language)
         case eLanguageTypeC_plus_plus_11:
         case eLanguageTypeC_plus_plus_14:
             return true;
         default:
             return false;
     }
 }
 
+bool
+LanguageRuntime::LanguageIsObjC (LanguageType language)
+{
+    switch (language)
+    {
+        case eLanguageTypeObjC:
+        case eLanguageTypeObjC_plus_plus:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool
+LanguageRuntime::LanguageIsC (LanguageType language)
+{
+    switch (language)
+    {
+        case eLanguageTypeC:
+        case eLanguageTypeC89:
+        case eLanguageTypeC99:
+        case eLanguageTypeC11:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool
+LanguageRuntime::LanguageIsPascal (LanguageType language)
+{
+    switch (language)
+    {
+        case eLanguageTypePascal83:
+            return true;
+        default:
+            return false;
+    }
+}
+
 void
 LanguageRuntime::InitializeCommands (CommandObject* parent)
 {
     if (!parent)
         return;
 
     if (!parent->IsMultiwordObject())
         return;

lldb/trunk/source/Target/Target.cpp

Target::CreateBreakpoint (Address &addr, bool internal, bool hardware)
     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, false);
 }
 
 BreakpointSP
 Target::CreateBreakpoint (const FileSpecList *containingModules,
                           const FileSpecList *containingSourceFiles,
                           const char *func_name, 
                           uint32_t func_name_type_mask, 
+                          LanguageType language,
                           LazyBool skip_prologue,
                           bool internal,
                           bool hardware)
 {
     BreakpointSP bp_sp;
     if (func_name)
     {
         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 
         if (skip_prologue == eLazyBoolCalculate)
             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
+        if (language == lldb::eLanguageTypeUnknown)
+            language = GetLanguage();
 
         BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, 
                                                                       func_name, 
                                                                       func_name_type_mask, 
+                                                                      language,
                                                                       Breakpoint::Exact, 
                                                                       skip_prologue));
         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
     }
     return bp_sp;
 }
 
 lldb::BreakpointSP
 Target::CreateBreakpoint (const FileSpecList *containingModules,
                           const FileSpecList *containingSourceFiles,
                           const std::vector<std::string> &func_names,
                           uint32_t func_name_type_mask,
+                          LanguageType language,
                           LazyBool skip_prologue,
                           bool internal,
                           bool hardware)
 {
     BreakpointSP bp_sp;
     size_t num_names = func_names.size();
     if (num_names > 0)
     {
         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
 
         if (skip_prologue == eLazyBoolCalculate)
             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
+        if (language == lldb::eLanguageTypeUnknown)
+            language = GetLanguage();
 
         BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
                                                                       func_names,
                                                                       func_name_type_mask,
+                                                                      language,
                                                                       skip_prologue));
         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
     }
     return bp_sp;
 }
 
 BreakpointSP
 Target::CreateBreakpoint (const FileSpecList *containingModules,
                           const FileSpecList *containingSourceFiles,
                           const char *func_names[],
                           size_t num_names, 
                           uint32_t func_name_type_mask, 
+                          LanguageType language,
                           LazyBool skip_prologue,
                           bool internal,
                           bool hardware)
 {
     BreakpointSP bp_sp;
     if (num_names > 0)
     {
         SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
         
         if (skip_prologue == eLazyBoolCalculate)
             skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
+        if (language == lldb::eLanguageTypeUnknown)
+            language = GetLanguage();
+
 
         BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
                                                                       func_names,
                                                                       num_names, 
                                                                       func_name_type_mask,
+                                                                      language,
                                                                       skip_prologue));
         bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
     }
     return bp_sp;
 }
 
 SearchFilterSP
 Target::GetSearchFilterForModule (const FileSpec *containingModule)
g_memory_module_load_level_values[] =
     { 0, NULL, NULL }
 };
 
 static PropertyDefinition
 g_properties[] =
 {
     { "default-arch"                       , OptionValue::eTypeArch      , true , 0                         , NULL, NULL, "Default architecture to choose, when there's a choice." },
     { "move-to-nearest-code"               , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Move breakpoints to nearest code." },
+    { "language"                           , OptionValue::eTypeLanguage  , false, eLanguageTypeUnknown      , NULL, NULL, "The language to use when interpreting expressions entered in commands (note: currently only implemented for breakpoints identifiers)." },
     { "expr-prefix"                        , OptionValue::eTypeFileSpec  , false, 0                         , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." },
     { "prefer-dynamic-value"               , OptionValue::eTypeEnum      , false, eDynamicDontRunTarget     , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." },
     { "enable-synthetic-value"             , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Should synthetic values be used by default whenever available." },
     { "skip-prologue"                      , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Skip function prologues when setting breakpoints by name." },
     { "source-map"                         , OptionValue::eTypePathMap   , false, 0                         , NULL, NULL, "Source path remappings used to track the change of location between a source file when built, and "
       "where it exists on the current system.  It consists of an array of duples, the first element of each duple is "
       "some part (starting at the root) of the path to the file when it was built, "
       "and the second is where the remainder of the original build hierarchy is rooted on the local system.  "
g_properties[] =
     { "non-stop-mode"                      , OptionValue::eTypeBoolean   , false, 0,                          NULL, NULL, "Disable lock-step debugging, instead control threads independently." },
     { NULL                                 , OptionValue::eTypeInvalid   , false, 0                         , NULL, NULL, NULL }
 };
 
 enum
 {
     ePropertyDefaultArch,
     ePropertyMoveToNearestCode,
+    ePropertyLanguage,
     ePropertyExprPrefix,
     ePropertyPreferDynamic,
     ePropertyEnableSynthetic,
     ePropertySkipPrologue,
     ePropertySourceMap,
     ePropertyExecutableSearchPaths,
     ePropertyDebugFileSearchPaths,
     ePropertyClangModuleSearchPaths,

 
 FileSpec
 TargetProperties::GetStandardErrorPath () const
 {
     const uint32_t idx = ePropertyErrorPath;
     return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx);
 }
 
+LanguageType
+TargetProperties::GetLanguage () const
+{
+    OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage (NULL, ePropertyLanguage);
+    if (value)
+        return value->GetCurrentValue();
+    return LanguageType();
+}
+
 const char *
 TargetProperties::GetExpressionPrefixContentsAsCString ()
 {
     const uint32_t idx = ePropertyExprPrefix;
     OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx);
     if (file)
     {
         const bool null_terminate = true;

lldb/trunk/test/functionalities/breakpoint/breakpoint_options/Makefile

 LEVEL = ../../../make
 
-C_SOURCES := main.c
+CXX_SOURCES := main.cpp foo.cpp
 
 include $(LEVEL)/Makefile.rules

lldb/trunk/test/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

def test_with_dwarf(self):
         """Test breakpoint command for different options."""
         self.buildDwarf()
         self.breakpoint_options_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
-        self.line = line_number('main.c', '// Set break point at this line.')
+        self.line = line_number('main.cpp', '// Set break point at this line.')
 
     def breakpoint_options_test(self):
         """Test breakpoint command for different options."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint with 1 locations.
-        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 1", num_expected_locations = 1)
-        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 0", num_expected_locations = 1)
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, extra_options = "-K 1", num_expected_locations = 1)
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, extra_options = "-K 0", num_expected_locations = 1)
 
         # This should create a breakpoint 0 locations.
-        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-m 0", num_expected_locations = 0)
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, extra_options = "-m 0", num_expected_locations = 0)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Stopped once.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ["stop reason = breakpoint 2."])
 
         # Check the list of breakpoint.
         self.expect("breakpoint list -f", "Breakpoint locations shown correctly",
-            substrs = ["1: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line,
-                       "2: file = 'main.c', line = %d, exact_match = 0, locations = 1" % self.line,
-                       "3: file = 'main.c', line = %d, exact_match = 1, locations = 0" % self.line])
+            substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.line,
+                       "2: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.line,
+                       "3: file = 'main.cpp', line = %d, exact_match = 1, locations = 0" % self.line])
 
         # Continue the program, there should be another stop.
         self.runCmd("process continue")
 
         # Stopped again.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ["stop reason = breakpoint 1."])
 
         # Continue the program, we should exit.
         self.runCmd("process continue")
 
         # We should exit.
         self.expect("process status", "Process exited successfully",
             patterns = ["^Process [0-9]+ exited with status = 0"])
 
+    def breakpoint_options_language_test(self):
+        """Test breakpoint command for language option."""
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # This should create a breakpoint with 1 locations.
+        lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, extra_options = "-L c++", num_expected_locations=1)
+
+        # This should create a breakpoint 0 locations.
+        lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, extra_options = "-L c", num_expected_locations=0)
+        self.runCmd("settings set target.language c")
+        lldbutil.run_break_set_by_symbol (self, 'ns::func', sym_exact=False, num_expected_locations=0)
+
+        # Run the program.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Stopped once.
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ["stop reason = breakpoint 1."])
+
+        # Continue the program, we should exit.
+        self.runCmd("process continue")
+
+        # We should exit.
+        self.expect("process status", "Process exited successfully",
+            patterns = ["^Process [0-9]+ exited with status = 0"])
+
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()

lldb/trunk/test/functionalities/breakpoint/breakpoint_options/foo.cpp

+
+namespace ns {
+    int func(void)
+    {
+        return 0;
+    }
+}
+
+extern "C" int foo(void)
+{
+    return ns::func();
+}

lldb/trunk/test/functionalities/breakpoint/breakpoint_options/main.c

-// Set break point at this line.
-
-int
-main (int argc, char **argv)
-{ 
-  return 0;
-}

lldb/trunk/test/functionalities/breakpoint/breakpoint_options/main.cpp

+// Set break point at this line.
+
+extern "C" int foo(void);
+int
+main (int argc, char **argv)
+{ 
+  return foo();
+}

lldb/trunk/test/settings/TestSettings.py

def test_settings_with_trailing_whitespace (self):
             startstr = 'target.output-path (file) = ', substrs=[path2])
         self.runCmd("settings clear target.output-path", check=False)
         # enum
         self.runCmd ("settings set stop-disassembly-display never")   # Set to known value
         self.runCmd ("settings set stop-disassembly-display always ") # Set to new value with trailing whitespaces
         self.expect ("settings show stop-disassembly-display", SETTING_MSG("stop-disassembly-display"),
             startstr = 'stop-disassembly-display (enum) = always')
         self.runCmd("settings clear stop-disassembly-display", check=False)        
+        # language
+        self.runCmd ("settings set target.language c89")      # Set to known value
+        self.runCmd ("settings set target.language pascal ")    # Set to new value with trailing whitespace
+        self.expect ("settings show target.language", SETTING_MSG("target.language"),
+            startstr = "target.language (language) = pascal")
+        self.runCmd("settings clear target.language", check=False)
         # arguments
         self.runCmd ("settings set target.run-args 1 2 3")  # Set to known value
         self.runCmd ("settings set target.run-args 3 4 5 ") # Set to new value with trailing whitespaces
         self.expect ("settings show target.run-args", SETTING_MSG("target.run-args"),
             substrs = [ 'target.run-args (arguments) =', 
                         '[0]: "3"', 
                         '[1]: "4"',
                         '[2]: "5"' ])
def test_all_settings_exist (self):
                                  "stop-line-count-after",
                                  "stop-line-count-before",
                                  "term-width",
                                  "thread-format",
                                  "use-external-editor",
                                  "target.default-arch",
                                  "target.move-to-nearest-code",
                                  "target.expr-prefix",
+                                 "target.language",
                                  "target.prefer-dynamic-value",
                                  "target.enable-synthetic-value",
                                  "target.skip-prologue",
                                  "target.source-map",
                                  "target.exec-search-paths",
                                  "target.max-children-count",
                                  "target.max-string-summary-length",
                                  "target.breakpoints-use-platform-avoid-list",

lldb/trunk/test/tools/lldb-mi/breakpoint/TestMiBreak.py

def test_lldbmi_break_insert_settings(self):
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"4\"")
 
         # Test that BP #3 is hit
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"3\"")
 
+        # Test that the target.language=pascal setting works and that BP #5 is not set
+        self.runCmd("-interpreter-exec console \"settings set target.language c\"")
+        self.expect("\^done")
+        self.runCmd("-break-insert ns.foo1")
+        self.expect("\^error")
+
+        # Test that the target.language=c++ setting works and that BP #6 is hit
+        # FIXME: lldb-mi interprets 'ns::func' as file:func where file='ns:'.
+        #self.runCmd("-interpreter-exec console \"settings set target.language c++\"")
+        #self.expect("\^done")
+        #self.runCmd("-break-insert ns::foo1")
+        #self.expect("\^done,bkpt={number=\"6\"")
+        #self.runCmd("-exec-run")
+        #self.expect("\^running")
+        #self.expect("\*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"6\"")
+
         # Test that BP #1 and #2 weren't set by running to program exit
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
 if __name__ == '__main__':
     unittest2.main()

lldb/trunk/test/tools/lldb-mi/breakpoint/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdio>
 
+namespace ns
+{
+    int foo1(void) { printf("In foo1\n"); return 1; }
+    int foo2(void) { printf("In foo2\n"); return 2; }
+}
+
 // BP_before_main
 
+int x;
 int
 main(int argc, char const *argv[])
 {
     printf("Print a formatted string so that GCC does not optimize this printf call: %s\n", argv[0]);
+    x = ns::foo1() + ns::foo2();
     return 0; // BP_return
 }