event_location_up string_to_explicit_location (const char **argp, const struct language_defn *language, explicit_completion_info *completion_info) { event_location_up location; /* It is assumed that input beginning with '-' and a non-digit character is an explicit location. "-p" is reserved, though, for probe locations. */ if (argp == NULL || *argp == NULL || *argp[0] != '-' || !isalpha ((*argp)[1]) || ((*argp)[0] == '-' && (*argp)[1] == 'p')) return NULL; location = new_explicit_location (NULL); /* Process option/argument pairs. dprintf_command requires that processing stop on ','. */ while ((*argp)[0] != '\0' && (*argp)[0] != ',') { int len; const char *start; /* Clear these on each iteration, since they should be filled with info about the last option. */ if (completion_info != NULL) { completion_info->quoted_arg_start = NULL; completion_info->quoted_arg_end = NULL; } /* If *ARGP starts with a keyword, stop processing options. */ if (linespec_lexer_lex_keyword (*argp) != NULL) break; /* Mark the start of the string in case we need to rewind. */ start = *argp; if (completion_info != NULL) completion_info->last_option = start; /* Get the option string. */ gdb::unique_xmalloc_ptr<char> opt = explicit_location_lex_one (argp, language, NULL); /* Use the length of the option to allow abbreviations. */ len = strlen (opt.get ()); /* Get the argument string. */ *argp = skip_spaces (*argp); /* All options have a required argument. Checking for this required argument is deferred until later. */ gdb::unique_xmalloc_ptr<char> oarg; /* True if we have an argument. This is required because we'll move from OARG before checking whether we have an argument. */ bool have_oarg = false; /* True if the option needs an argument. */ bool need_oarg = false; /* Convenience to consistently set both OARG/HAVE_OARG from ARG. */ auto set_oarg = [&] (gdb::unique_xmalloc_ptr<char> arg) { if (completion_info != NULL) { /* We do this here because the set of options that take arguments matches the set of explicit location options. */ completion_info->saw_explicit_location_option = true; } oarg = std::move (arg); have_oarg = oarg != NULL; need_oarg = true; }; if (strncmp (opt.get (), "-source", len) == 0) { set_oarg (explicit_location_lex_one (argp, language, completion_info)); EL_EXPLICIT (location)->source_filename = oarg.release (); } else if (strncmp (opt.get (), "-function", len) == 0) { set_oarg (explicit_location_lex_one_function (argp, language, completion_info)); EL_EXPLICIT (location)->function_name = oarg.release (); } else if (strncmp (opt.get (), "-qualified", len) == 0) { EL_EXPLICIT (location)->func_name_match_type = symbol_name_match_type::FULL; } else if (strncmp (opt.get (), "-line", len) == 0) { set_oarg (explicit_location_lex_one (argp, language, NULL)); *argp = skip_spaces (*argp); if (have_oarg) { EL_EXPLICIT (location)->line_offset = linespec_parse_line_offset (oarg.get ()); continue; } } else if (strncmp (opt.get (), "-label", len) == 0) { set_oarg (explicit_location_lex_one (argp, language, completion_info)); EL_EXPLICIT (location)->label_name = oarg.release (); } /* Only emit an "invalid argument" error for options that look like option strings. */ else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1])) { if (completion_info == NULL) error (_("invalid explicit location argument, \"%s\""), opt.get ()); } else { /* End of the explicit location specification. Stop parsing and return whatever explicit location was parsed. */ *argp = start; break; } *argp = skip_spaces (*argp); /* It's a little lame to error after the fact, but in this case, it provides a much better user experience to issue the "invalid argument" error before any missing argument error. */ if (need_oarg && !have_oarg && completion_info == NULL) error (_("missing argument for \"%s\""), opt.get ()); } /* One special error check: If a source filename was given without offset, function, or label, issue an error. */ if (EL_EXPLICIT (location)->source_filename != NULL && EL_EXPLICIT (location)->function_name == NULL && EL_EXPLICIT (location)->label_name == NULL && (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN) && completion_info == NULL) { error (_("Source filename requires function, label, or " "line offset.")); } return location; }
event_location_up string_to_explicit_location (const char **argp, const struct language_defn *language, int dont_throw) { event_location_up location; /* It is assumed that input beginning with '-' and a non-digit character is an explicit location. "-p" is reserved, though, for probe locations. */ if (argp == NULL || *argp == NULL || *argp[0] != '-' || !isalpha ((*argp)[1]) || ((*argp)[0] == '-' && (*argp)[1] == 'p')) return NULL; location = new_explicit_location (NULL); /* Process option/argument pairs. dprintf_command requires that processing stop on ','. */ while ((*argp)[0] != '\0' && (*argp)[0] != ',') { int len; const char *start; /* If *ARGP starts with a keyword, stop processing options. */ if (linespec_lexer_lex_keyword (*argp) != NULL) break; /* Mark the start of the string in case we need to rewind. */ start = *argp; /* Get the option string. */ gdb::unique_xmalloc_ptr<char> opt = explicit_location_lex_one (argp, language); *argp = skip_spaces_const (*argp); /* Get the argument string. */ gdb::unique_xmalloc_ptr<char> oarg = explicit_location_lex_one (argp, language); bool have_oarg = oarg != NULL; *argp = skip_spaces_const (*argp); /* Use the length of the option to allow abbreviations. */ len = strlen (opt.get ()); /* All options have a required argument. Checking for this required argument is deferred until later. */ if (strncmp (opt.get (), "-source", len) == 0) EL_EXPLICIT (location)->source_filename = oarg.release (); else if (strncmp (opt.get (), "-function", len) == 0) EL_EXPLICIT (location)->function_name = oarg.release (); else if (strncmp (opt.get (), "-line", len) == 0) { if (have_oarg) EL_EXPLICIT (location)->line_offset = linespec_parse_line_offset (oarg.get ()); } else if (strncmp (opt.get (), "-label", len) == 0) EL_EXPLICIT (location)->label_name = oarg.release (); /* Only emit an "invalid argument" error for options that look like option strings. */ else if (opt.get ()[0] == '-' && !isdigit (opt.get ()[1])) { if (!dont_throw) error (_("invalid explicit location argument, \"%s\""), opt.get ()); } else { /* End of the explicit location specification. Stop parsing and return whatever explicit location was parsed. */ *argp = start; return location; } /* It's a little lame to error after the fact, but in this case, it provides a much better user experience to issue the "invalid argument" error before any missing argument error. */ if (!have_oarg && !dont_throw) error (_("missing argument for \"%s\""), opt.get ()); } /* One special error check: If a source filename was given without offset, function, or label, issue an error. */ if (EL_EXPLICIT (location)->source_filename != NULL && EL_EXPLICIT (location)->function_name == NULL && EL_EXPLICIT (location)->label_name == NULL && (EL_EXPLICIT (location)->line_offset.sign == LINE_OFFSET_UNKNOWN) && !dont_throw) { error (_("Source filename requires function, label, or " "line offset.")); } return location; }
static void mi_cmd_break_insert_1 (int dprintf, char *command, char **argv, int argc) { char *address = NULL; int hardware = 0; int temp_p = 0; int thread = -1; int ignore_count = 0; char *condition = NULL; int pending = 0; int enabled = 1; int tracepoint = 0; struct cleanup *back_to = make_cleanup (null_cleanup, NULL); enum bptype type_wanted; struct event_location *location; struct breakpoint_ops *ops; int is_explicit = 0; struct explicit_location explicit_loc; char *extra_string = NULL; enum opt { HARDWARE_OPT, TEMP_OPT, CONDITION_OPT, IGNORE_COUNT_OPT, THREAD_OPT, PENDING_OPT, DISABLE_OPT, TRACEPOINT_OPT, EXPLICIT_SOURCE_OPT, EXPLICIT_FUNC_OPT, EXPLICIT_LABEL_OPT, EXPLICIT_LINE_OPT }; static const struct mi_opt opts[] = { {"h", HARDWARE_OPT, 0}, {"t", TEMP_OPT, 0}, {"c", CONDITION_OPT, 1}, {"i", IGNORE_COUNT_OPT, 1}, {"p", THREAD_OPT, 1}, {"f", PENDING_OPT, 0}, {"d", DISABLE_OPT, 0}, {"a", TRACEPOINT_OPT, 0}, {"-source" , EXPLICIT_SOURCE_OPT, 1}, {"-function", EXPLICIT_FUNC_OPT, 1}, {"-label", EXPLICIT_LABEL_OPT, 1}, {"-line", EXPLICIT_LINE_OPT, 1}, { 0, 0, 0 } }; /* Parse arguments. It could be -r or -h or -t, <location> or ``--'' to denote the end of the option list. */ int oind = 0; char *oarg; initialize_explicit_location (&explicit_loc); while (1) { int opt = mi_getopt ("-break-insert", argc, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case TEMP_OPT: temp_p = 1; break; case HARDWARE_OPT: hardware = 1; break; case CONDITION_OPT: condition = oarg; break; case IGNORE_COUNT_OPT: ignore_count = atol (oarg); break; case THREAD_OPT: thread = atol (oarg); break; case PENDING_OPT: pending = 1; break; case DISABLE_OPT: enabled = 0; break; case TRACEPOINT_OPT: tracepoint = 1; break; case EXPLICIT_SOURCE_OPT: is_explicit = 1; explicit_loc.source_filename = oarg; break; case EXPLICIT_FUNC_OPT: is_explicit = 1; explicit_loc.function_name = oarg; break; case EXPLICIT_LABEL_OPT: is_explicit = 1; explicit_loc.label_name = oarg; break; case EXPLICIT_LINE_OPT: is_explicit = 1; explicit_loc.line_offset = linespec_parse_line_offset (oarg); break; } } if (oind >= argc && !is_explicit) error (_("-%s-insert: Missing <location>"), dprintf ? "dprintf" : "break"); if (dprintf) { int format_num = is_explicit ? oind : oind + 1; if (hardware || tracepoint) error (_("-dprintf-insert: does not support -h or -a")); if (format_num >= argc) error (_("-dprintf-insert: Missing <format>")); extra_string = mi_argv_to_format (argv + format_num, argc - format_num); make_cleanup (xfree, extra_string); address = argv[oind]; } else { if (is_explicit) { if (oind < argc) error (_("-break-insert: Garbage following explicit location")); } else { if (oind < argc - 1) error (_("-break-insert: Garbage following <location>")); address = argv[oind]; } } /* Now we have what we need, let's insert the breakpoint! */ setup_breakpoint_reporting (); if (tracepoint) { /* Note that to request a fast tracepoint, the client uses the "hardware" flag, although there's nothing of hardware related to fast tracepoints -- one can implement slow tracepoints with hardware breakpoints, but fast tracepoints are always software. "fast" is a misnomer, actually, "jump" would be more appropriate. A simulator or an emulator could conceivably implement fast regular non-jump based tracepoints. */ type_wanted = hardware ? bp_fast_tracepoint : bp_tracepoint; ops = &tracepoint_breakpoint_ops; } else if (dprintf) { type_wanted = bp_dprintf; ops = &dprintf_breakpoint_ops; } else { type_wanted = hardware ? bp_hardware_breakpoint : bp_breakpoint; ops = &bkpt_breakpoint_ops; } if (is_explicit) { /* Error check -- we must have one of the other parameters specified. */ if (explicit_loc.source_filename != NULL && explicit_loc.function_name == NULL && explicit_loc.label_name == NULL && explicit_loc.line_offset.sign == LINE_OFFSET_UNKNOWN) error (_("-%s-insert: --source option requires --function, --label," " or --line"), dprintf ? "dprintf" : "break"); location = new_explicit_location (&explicit_loc); } else { location = string_to_event_location_basic (&address, current_language); if (*address) { delete_event_location (location); error (_("Garbage '%s' at end of location"), address); } } make_cleanup_delete_event_location (location); create_breakpoint (get_current_arch (), location, condition, thread, extra_string, 0 /* condition and thread are valid. */, temp_p, type_wanted, ignore_count, pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE, ops, 0, enabled, 0, 0); do_cleanups (back_to); }