Which language when parsing a breakpoint condition?

[Joel Brobecker <brobecker at gnat dot com>]

A friend of mine just asked this question: When you have a multilanguage
application (say Ada and C), if the current language is auto,c and you
place a conditional breakpoint inside Ada code, which language should be
used to parse and evaluate the condition? Ada or C.

Intuitevely, I would have say: the Ada parser, since we will be in an
Ada function when the breakpoint exception is evaluated. However, GDB
currently uses the parser of the language that is current at the time
when the user sets the condition (either with the "if" keyword of the
"break" command, or when using the "condition" command). So GDB
currently uses the C parser. Shouldn't it be the opposite?

Looking at the code, I think it is fairly easy to change the behavior
to be: 
  1. If the language is auto, then:
     a. Determine the language associated to the code where the breakpoint
        is set, and use it to parse and evaluate the condition
     b. If unable to determine the language, then use the current language.
  2. If the language mode is not auto, then: use the current language.
  
If the langauge is auto, then use the language associated to
the code where the breakpoint is set - if unable to determine the
language, then use the current langauge. 

Use the language associated to the code where the breakpoint
is set to evaluate the 


language_auto????

Looking at parse_exp_1: I think we can provide the other behavior by
replacing the following call...

    if (current_language->la_parser ())

... by something like this:

    struct language_defn *lang = NULL;
    if (language_mode == language_auto)
      {
        /* Find the language associated to the context block.
           Default to the current language if it can not be determined.  */
        struct symbol *func = block_function (expression_context_block);
        if (func != NULL)
          lang = language_def (SYMBOL_LANGUAGE (func));
        if (lang == NULL)
          lang = current_language;
      }
    else
      {
        /* Use the current language to parse the string.  */
        lang = current_language;
      }

    /* Parse the string.  */
    if (lang->la_parser ())

Sounds reasonable?

-- 
Joel